var JSAudioInterComModule = (function () {
  var _scriptDir =
    typeof document !== 'undefined' && document.currentScript
      ? document.currentScript.src
      : undefined;
  if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename;
  return function (JSAudioInterComModule) {
    JSAudioInterComModule = JSAudioInterComModule || {};

    var Module =
      typeof JSAudioInterComModule !== 'undefined' ? JSAudioInterComModule : {};
    var readyPromiseResolve, readyPromiseReject;
    Module['ready'] = new Promise(function (resolve, reject) {
      readyPromiseResolve = resolve;
      readyPromiseReject = reject;
    });
    var moduleOverrides = {};
    var key;
    for (key in Module) {
      if (Module.hasOwnProperty(key)) {
        moduleOverrides[key] = Module[key];
      }
    }
    var arguments_ = [];
    var thisProgram = './this.program';
    var quit_ = function (status, toThrow) {
      throw toThrow;
    };
    var ENVIRONMENT_IS_WEB = typeof window === 'object';
    var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';
    var ENVIRONMENT_IS_NODE =
      typeof process === 'object' &&
      typeof process.versions === 'object' &&
      typeof process.versions.node === 'string';
    var ENVIRONMENT_IS_PTHREAD = Module['ENVIRONMENT_IS_PTHREAD'] || false;
    var scriptDirectory = '';
    function locateFile(path) {
      if (Module['locateFile']) {
        return Module['locateFile'](path, scriptDirectory);
      }
      return scriptDirectory + path;
    }
    var read_, readAsync, readBinary, setWindowTitle;
    var nodeFS;
    var nodePath;
    if (ENVIRONMENT_IS_NODE) {
      if (ENVIRONMENT_IS_WORKER) {
        scriptDirectory = require('path').dirname(scriptDirectory) + '/';
      } else {
        scriptDirectory = __dirname + '/';
      }
      read_ = function shell_read(filename, binary) {
        if (!nodeFS) nodeFS = require('fs');
        if (!nodePath) nodePath = require('path');
        filename = nodePath['normalize'](filename);
        return nodeFS['readFileSync'](filename, binary ? null : 'utf8');
      };
      readBinary = function readBinary(filename) {
        var ret = read_(filename, true);
        if (!ret.buffer) {
          ret = new Uint8Array(ret);
        }
        assert(ret.buffer);
        return ret;
      };
      readAsync = function readAsync(filename, onload, onerror) {
        if (!nodeFS) nodeFS = require('fs');
        if (!nodePath) nodePath = require('path');
        filename = nodePath['normalize'](filename);
        nodeFS['readFile'](filename, function (err, data) {
          if (err) onerror(err);
          else onload(data.buffer);
        });
      };
      if (process['argv'].length > 1) {
        thisProgram = process['argv'][1].replace(/\\/g, '/');
      }
      arguments_ = process['argv'].slice(2);
      process['on']('uncaughtException', function (ex) {
        if (!(ex instanceof ExitStatus)) {
          throw ex;
        }
      });
      process['on']('unhandledRejection', abort);
      quit_ = function (status, toThrow) {
        if (keepRuntimeAlive()) {
          process['exitCode'] = status;
          throw toThrow;
        }
        process['exit'](status);
      };
      Module['inspect'] = function () {
        return '[Emscripten Module object]';
      };
      var nodeWorkerThreads;
      try {
        nodeWorkerThreads = require('worker_threads');
      } catch (e) {
        console.error(
          'The "worker_threads" module is not supported in this node.js build - perhaps a newer version is needed?'
        );
        throw e;
      }
      global.Worker = nodeWorkerThreads.Worker;
    } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
      if (ENVIRONMENT_IS_WORKER) {
        scriptDirectory = self.location.href;
      } else if (typeof document !== 'undefined' && document.currentScript) {
        scriptDirectory = document.currentScript.src;
      }
      if (_scriptDir) {
        scriptDirectory = _scriptDir;
      }
      if (scriptDirectory.indexOf('blob:') !== 0) {
        scriptDirectory = scriptDirectory.substr(
          0,
          scriptDirectory.lastIndexOf('/') + 1
        );
      } else {
        scriptDirectory = '';
      }
      if (ENVIRONMENT_IS_NODE) {
        read_ = function shell_read(filename, binary) {
          if (!nodeFS) nodeFS = require('fs');
          if (!nodePath) nodePath = require('path');
          filename = nodePath['normalize'](filename);
          return nodeFS['readFileSync'](filename, binary ? null : 'utf8');
        };
        readBinary = function readBinary(filename) {
          var ret = read_(filename, true);
          if (!ret.buffer) {
            ret = new Uint8Array(ret);
          }
          assert(ret.buffer);
          return ret;
        };
        readAsync = function readAsync(filename, onload, onerror) {
          if (!nodeFS) nodeFS = require('fs');
          if (!nodePath) nodePath = require('path');
          filename = nodePath['normalize'](filename);
          nodeFS['readFile'](filename, function (err, data) {
            if (err) onerror(err);
            else onload(data.buffer);
          });
        };
      } else {
        read_ = function (url) {
          var xhr = new XMLHttpRequest();
          xhr.open('GET', url, false);
          xhr.send(null);
          return xhr.responseText;
        };
        if (ENVIRONMENT_IS_WORKER) {
          readBinary = function (url) {
            var xhr = new XMLHttpRequest();
            xhr.open('GET', url, false);
            xhr.responseType = 'arraybuffer';
            xhr.send(null);
            return new Uint8Array(xhr.response);
          };
        }
        readAsync = function (url, onload, onerror) {
          var xhr = new XMLHttpRequest();
          xhr.open('GET', url, true);
          xhr.responseType = 'arraybuffer';
          xhr.onload = function () {
            if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) {
              onload(xhr.response);
              return;
            }
            onerror();
          };
          xhr.onerror = onerror;
          xhr.send(null);
        };
      }
      setWindowTitle = function (title) {
        document.title = title;
      };
    } else {
    }
    if (ENVIRONMENT_IS_NODE) {
      if (typeof performance === 'undefined') {
        global.performance = require('perf_hooks').performance;
      }
    }
    var out = Module['print'] || console.log.bind(console);
    var err = Module['printErr'] || console.warn.bind(console);
    for (key in moduleOverrides) {
      if (moduleOverrides.hasOwnProperty(key)) {
        Module[key] = moduleOverrides[key];
      }
    }
    moduleOverrides = null;
    if (Module['arguments']) arguments_ = Module['arguments'];
    if (Module['thisProgram']) thisProgram = Module['thisProgram'];
    if (Module['quit']) quit_ = Module['quit'];
    function warnOnce(text) {
      if (!warnOnce.shown) warnOnce.shown = {};
      if (!warnOnce.shown[text]) {
        warnOnce.shown[text] = 1;
        err(text);
      }
    }
    var tempRet0 = 0;
    var setTempRet0 = function (value) {
      tempRet0 = value;
    };
    var Atomics_load = Atomics.load;
    var Atomics_store = Atomics.store;
    var Atomics_compareExchange = Atomics.compareExchange;
    var wasmBinary;
    if (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];
    var noExitRuntime = Module['noExitRuntime'] || true;
    if (typeof WebAssembly !== 'object') {
      abort('no native wasm support detected');
    }
    function getValue(ptr, type, noSafe) {
      type = type || 'i8';
      if (type.charAt(type.length - 1) === '*') type = 'i32';
      switch (type) {
        case 'i1':
          return HEAP8[ptr >> 0];
        case 'i8':
          return HEAP8[ptr >> 0];
        case 'i16':
          return HEAP16[ptr >> 1];
        case 'i32':
          return HEAP32[ptr >> 2];
        case 'i64':
          return HEAP32[ptr >> 2];
        case 'float':
          return HEAPF32[ptr >> 2];
        case 'double':
          return HEAPF64[ptr >> 3];
        default:
          abort('invalid type for getValue: ' + type);
      }
      return null;
    }
    var wasmMemory;
    var wasmModule;
    var ABORT = false;
    var EXITSTATUS;
    function assert(condition, text) {
      if (!condition) {
        abort('Assertion failed: ' + text);
      }
    }
    function getCFunc(ident) {
      var func = Module['_' + ident];
      assert(
        func,
        'Cannot call unknown function ' + ident + ', make sure it is exported'
      );
      return func;
    }
    function ccall(ident, returnType, argTypes, args, opts) {
      var toC = {
        string: function (str) {
          var ret = 0;
          if (str !== null && str !== undefined && str !== 0) {
            var len = (str.length << 2) + 1;
            ret = stackAlloc(len);
            stringToUTF8(str, ret, len);
          }
          return ret;
        },
        array: function (arr) {
          var ret = stackAlloc(arr.length);
          writeArrayToMemory(arr, ret);
          return ret;
        }
      };
      function convertReturnValue(ret) {
        if (returnType === 'string') return UTF8ToString(ret);
        if (returnType === 'boolean') return Boolean(ret);
        return ret;
      }
      var func = getCFunc(ident);
      var cArgs = [];
      var stack = 0;
      if (args) {
        for (var i = 0; i < args.length; i++) {
          var converter = toC[argTypes[i]];
          if (converter) {
            if (stack === 0) stack = stackSave();
            cArgs[i] = converter(args[i]);
          } else {
            cArgs[i] = args[i];
          }
        }
      }
      var ret = func.apply(null, cArgs);
      function onDone(ret) {
        if (stack !== 0) stackRestore(stack);
        return convertReturnValue(ret);
      }
      ret = onDone(ret);
      return ret;
    }
    var ALLOC_NORMAL = 0;
    var ALLOC_STACK = 1;
    function allocate(slab, allocator) {
      var ret;
      if (allocator == ALLOC_STACK) {
        ret = stackAlloc(slab.length);
      } else {
        ret = _malloc(slab.length);
      }
      if (slab.subarray || slab.slice) {
        HEAPU8.set(slab, ret);
      } else {
        HEAPU8.set(new Uint8Array(slab), ret);
      }
      return ret;
    }
    function TextDecoderWrapper(encoding) {
      var textDecoder = new TextDecoder(encoding);
      this.decode = function (data) {
        if (data.buffer instanceof SharedArrayBuffer) {
          data = new Uint8Array(data);
        }
        return textDecoder.decode.call(textDecoder, data);
      };
    }
    var UTF8Decoder =
      typeof TextDecoder !== 'undefined'
        ? new TextDecoderWrapper('utf8')
        : undefined;
    function UTF8ArrayToString(heap, idx, maxBytesToRead) {
      var endIdx = idx + maxBytesToRead;
      var endPtr = idx;
      while (heap[endPtr] && !(endPtr >= endIdx)) ++endPtr;
      if (endPtr - idx > 16 && heap.subarray && UTF8Decoder) {
        return UTF8Decoder.decode(heap.subarray(idx, endPtr));
      } else {
        var str = '';
        while (idx < endPtr) {
          var u0 = heap[idx++];
          if (!(u0 & 128)) {
            str += String.fromCharCode(u0);
            continue;
          }
          var u1 = heap[idx++] & 63;
          if ((u0 & 224) == 192) {
            str += String.fromCharCode(((u0 & 31) << 6) | u1);
            continue;
          }
          var u2 = heap[idx++] & 63;
          if ((u0 & 240) == 224) {
            u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;
          } else {
            u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heap[idx++] & 63);
          }
          if (u0 < 65536) {
            str += String.fromCharCode(u0);
          } else {
            var ch = u0 - 65536;
            str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
          }
        }
      }
      return str;
    }
    function UTF8ToString(ptr, maxBytesToRead) {
      return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';
    }
    function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {
      if (!(maxBytesToWrite > 0)) return 0;
      var startIdx = outIdx;
      var endIdx = outIdx + maxBytesToWrite - 1;
      for (var i = 0; i < str.length; ++i) {
        var u = str.charCodeAt(i);
        if (u >= 55296 && u <= 57343) {
          var u1 = str.charCodeAt(++i);
          u = (65536 + ((u & 1023) << 10)) | (u1 & 1023);
        }
        if (u <= 127) {
          if (outIdx >= endIdx) break;
          heap[outIdx++] = u;
        } else if (u <= 2047) {
          if (outIdx + 1 >= endIdx) break;
          heap[outIdx++] = 192 | (u >> 6);
          heap[outIdx++] = 128 | (u & 63);
        } else if (u <= 65535) {
          if (outIdx + 2 >= endIdx) break;
          heap[outIdx++] = 224 | (u >> 12);
          heap[outIdx++] = 128 | ((u >> 6) & 63);
          heap[outIdx++] = 128 | (u & 63);
        } else {
          if (outIdx + 3 >= endIdx) break;
          heap[outIdx++] = 240 | (u >> 18);
          heap[outIdx++] = 128 | ((u >> 12) & 63);
          heap[outIdx++] = 128 | ((u >> 6) & 63);
          heap[outIdx++] = 128 | (u & 63);
        }
      }
      heap[outIdx] = 0;
      return outIdx - startIdx;
    }
    function stringToUTF8(str, outPtr, maxBytesToWrite) {
      return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
    }
    function lengthBytesUTF8(str) {
      var len = 0;
      for (var i = 0; i < str.length; ++i) {
        var u = str.charCodeAt(i);
        if (u >= 55296 && u <= 57343)
          u = (65536 + ((u & 1023) << 10)) | (str.charCodeAt(++i) & 1023);
        if (u <= 127) ++len;
        else if (u <= 2047) len += 2;
        else if (u <= 65535) len += 3;
        else len += 4;
      }
      return len;
    }
    var UTF16Decoder =
      typeof TextDecoder !== 'undefined'
        ? new TextDecoderWrapper('utf-16le')
        : undefined;
    function UTF16ToString(ptr, maxBytesToRead) {
      var endPtr = ptr;
      var idx = endPtr >> 1;
      var maxIdx = idx + maxBytesToRead / 2;
      while (!(idx >= maxIdx) && HEAPU16[idx]) ++idx;
      endPtr = idx << 1;
      if (endPtr - ptr > 32 && UTF16Decoder) {
        return UTF16Decoder.decode(HEAPU8.subarray(ptr, endPtr));
      } else {
        var str = '';
        for (var i = 0; !(i >= maxBytesToRead / 2); ++i) {
          var codeUnit = HEAP16[(ptr + i * 2) >> 1];
          if (codeUnit == 0) break;
          str += String.fromCharCode(codeUnit);
        }
        return str;
      }
    }
    function stringToUTF16(str, outPtr, maxBytesToWrite) {
      if (maxBytesToWrite === undefined) {
        maxBytesToWrite = 2147483647;
      }
      if (maxBytesToWrite < 2) return 0;
      maxBytesToWrite -= 2;
      var startPtr = outPtr;
      var numCharsToWrite =
        maxBytesToWrite < str.length * 2 ? maxBytesToWrite / 2 : str.length;
      for (var i = 0; i < numCharsToWrite; ++i) {
        var codeUnit = str.charCodeAt(i);
        HEAP16[outPtr >> 1] = codeUnit;
        outPtr += 2;
      }
      HEAP16[outPtr >> 1] = 0;
      return outPtr - startPtr;
    }
    function lengthBytesUTF16(str) {
      return str.length * 2;
    }
    function UTF32ToString(ptr, maxBytesToRead) {
      var i = 0;
      var str = '';
      while (!(i >= maxBytesToRead / 4)) {
        var utf32 = HEAP32[(ptr + i * 4) >> 2];
        if (utf32 == 0) break;
        ++i;
        if (utf32 >= 65536) {
          var ch = utf32 - 65536;
          str += String.fromCharCode(55296 | (ch >> 10), 56320 | (ch & 1023));
        } else {
          str += String.fromCharCode(utf32);
        }
      }
      return str;
    }
    function stringToUTF32(str, outPtr, maxBytesToWrite) {
      if (maxBytesToWrite === undefined) {
        maxBytesToWrite = 2147483647;
      }
      if (maxBytesToWrite < 4) return 0;
      var startPtr = outPtr;
      var endPtr = startPtr + maxBytesToWrite - 4;
      for (var i = 0; i < str.length; ++i) {
        var codeUnit = str.charCodeAt(i);
        if (codeUnit >= 55296 && codeUnit <= 57343) {
          var trailSurrogate = str.charCodeAt(++i);
          codeUnit =
            (65536 + ((codeUnit & 1023) << 10)) | (trailSurrogate & 1023);
        }
        HEAP32[outPtr >> 2] = codeUnit;
        outPtr += 4;
        if (outPtr + 4 > endPtr) break;
      }
      HEAP32[outPtr >> 2] = 0;
      return outPtr - startPtr;
    }
    function lengthBytesUTF32(str) {
      var len = 0;
      for (var i = 0; i < str.length; ++i) {
        var codeUnit = str.charCodeAt(i);
        if (codeUnit >= 55296 && codeUnit <= 57343) ++i;
        len += 4;
      }
      return len;
    }
    function writeArrayToMemory(array, buffer) {
      HEAP8.set(array, buffer);
    }
    var buffer,
      HEAP8,
      HEAPU8,
      HEAP16,
      HEAPU16,
      HEAP32,
      HEAPU32,
      HEAPF32,
      HEAPF64;
    if (ENVIRONMENT_IS_PTHREAD) {
      buffer = Module['buffer'];
    }
    function updateGlobalBufferAndViews(buf) {
      buffer = buf;
      Module['HEAP8'] = HEAP8 = new Int8Array(buf);
      Module['HEAP16'] = HEAP16 = new Int16Array(buf);
      Module['HEAP32'] = HEAP32 = new Int32Array(buf);
      Module['HEAPU8'] = HEAPU8 = new Uint8Array(buf);
      Module['HEAPU16'] = HEAPU16 = new Uint16Array(buf);
      Module['HEAPU32'] = HEAPU32 = new Uint32Array(buf);
      Module['HEAPF32'] = HEAPF32 = new Float32Array(buf);
      Module['HEAPF64'] = HEAPF64 = new Float64Array(buf);
    }
    var INITIAL_MEMORY = Module['INITIAL_MEMORY'] || 134217728;
    if (ENVIRONMENT_IS_PTHREAD) {
      wasmMemory = Module['wasmMemory'];
      buffer = Module['buffer'];
    } else {
      if (Module['wasmMemory']) {
        wasmMemory = Module['wasmMemory'];
      } else {
        wasmMemory = new WebAssembly.Memory({
          initial: INITIAL_MEMORY / 65536,
          maximum: INITIAL_MEMORY / 65536,
          shared: true
        });
        if (!(wasmMemory.buffer instanceof SharedArrayBuffer)) {
          err(
            'requested a shared WebAssembly.Memory but the returned buffer is not a SharedArrayBuffer, indicating that while the browser has SharedArrayBuffer it does not have WebAssembly threads support - you may need to set a flag'
          );
          if (ENVIRONMENT_IS_NODE) {
            console.log(
              '(on node you may need: --experimental-wasm-threads --experimental-wasm-bulk-memory and also use a recent version)'
            );
          }
          throw Error('bad memory');
        }
      }
    }
    if (wasmMemory) {
      buffer = wasmMemory.buffer;
    }
    INITIAL_MEMORY = buffer.byteLength;
    updateGlobalBufferAndViews(buffer);
    var wasmTable;
    var __ATPRERUN__ = [];
    var __ATINIT__ = [];
    var __ATEXIT__ = [];
    var __ATPOSTRUN__ = [];
    var runtimeInitialized = false;
    var runtimeExited = false;
    var runtimeKeepaliveCounter = 0;
    function keepRuntimeAlive() {
      return noExitRuntime || runtimeKeepaliveCounter > 0;
    }
    function preRun() {
      if (ENVIRONMENT_IS_PTHREAD) return;
      if (Module['preRun']) {
        if (typeof Module['preRun'] == 'function')
          Module['preRun'] = [Module['preRun']];
        while (Module['preRun'].length) {
          addOnPreRun(Module['preRun'].shift());
        }
      }
      callRuntimeCallbacks(__ATPRERUN__);
    }
    function initRuntime() {
      runtimeInitialized = true;
      if (ENVIRONMENT_IS_PTHREAD) return;
      callRuntimeCallbacks(__ATINIT__);
    }
    function exitRuntime() {
      if (ENVIRONMENT_IS_PTHREAD) return;
      runtimeExited = true;
    }
    function postRun() {
      if (ENVIRONMENT_IS_PTHREAD) return;
      if (Module['postRun']) {
        if (typeof Module['postRun'] == 'function')
          Module['postRun'] = [Module['postRun']];
        while (Module['postRun'].length) {
          addOnPostRun(Module['postRun'].shift());
        }
      }
      callRuntimeCallbacks(__ATPOSTRUN__);
    }
    function addOnPreRun(cb) {
      __ATPRERUN__.unshift(cb);
    }
    function addOnInit(cb) {
      __ATINIT__.unshift(cb);
    }
    function addOnPostRun(cb) {
      __ATPOSTRUN__.unshift(cb);
    }
    var runDependencies = 0;
    var runDependencyWatcher = null;
    var dependenciesFulfilled = null;
    function addRunDependency(id) {
      runDependencies++;
      if (Module['monitorRunDependencies']) {
        Module['monitorRunDependencies'](runDependencies);
      }
    }
    function removeRunDependency(id) {
      runDependencies--;
      if (Module['monitorRunDependencies']) {
        Module['monitorRunDependencies'](runDependencies);
      }
      if (runDependencies == 0) {
        if (runDependencyWatcher !== null) {
          clearInterval(runDependencyWatcher);
          runDependencyWatcher = null;
        }
        if (dependenciesFulfilled) {
          var callback = dependenciesFulfilled;
          dependenciesFulfilled = null;
          callback();
        }
      }
    }
    Module['preloadedImages'] = {};
    Module['preloadedAudios'] = {};
    function abort(what) {
      if (ENVIRONMENT_IS_PTHREAD) {
        postMessage({ cmd: 'onAbort', arg: what });
      } else {
        if (Module['onAbort']) {
          Module['onAbort'](what);
        }
      }
      what += '';
      err(what);
      ABORT = true;
      EXITSTATUS = 1;
      what = 'abort(' + what + '). Build with -s ASSERTIONS=1 for more info.';
      var e = new WebAssembly.RuntimeError(what);
      readyPromiseReject(e);
      throw e;
    }
    var dataURIPrefix = 'data:application/octet-stream;base64,';
    function isDataURI(filename) {
      return filename.startsWith(dataURIPrefix);
    }
    function isFileURI(filename) {
      return filename.startsWith('file://');
    }
    var wasmBinaryFile;
    wasmBinaryFile = 'AudioInterCom.wasm';
    if (!isDataURI(wasmBinaryFile)) {
      wasmBinaryFile = locateFile(wasmBinaryFile);
    }
    function getBinary(file) {
      try {
        if (file == wasmBinaryFile && wasmBinary) {
          return new Uint8Array(wasmBinary);
        }
        if (readBinary) {
          return readBinary(file);
        } else {
          throw 'both async and sync fetching of the wasm failed';
        }
      } catch (err) {
        abort(err);
      }
    }
    function getBinaryPromise() {
      if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {
        if (typeof fetch === 'function' && !isFileURI(wasmBinaryFile)) {
          return fetch(wasmBinaryFile, { credentials: 'same-origin' })
            .then(function (response) {
              if (!response['ok']) {
                throw (
                  "failed to load wasm binary file at '" + wasmBinaryFile + "'"
                );
              }
              return response['arrayBuffer']();
            })
            .catch(function () {
              return getBinary(wasmBinaryFile);
            });
        } else {
          if (readAsync) {
            return new Promise(function (resolve, reject) {
              readAsync(
                wasmBinaryFile,
                function (response) {
                  resolve(new Uint8Array(response));
                },
                reject
              );
            });
          }
        }
      }
      return Promise.resolve().then(function () {
        return getBinary(wasmBinaryFile);
      });
    }
    function createWasm() {
      var info = { a: asmLibraryArg };
      function receiveInstance(instance, module) {
        var exports = instance.exports;
        Module['asm'] = exports;
        wasmTable = Module['asm']['xb'];
        addOnInit(Module['asm']['Ga']);
        PThread.tlsInitFunctions.push(Module['asm']['wb']);
        wasmModule = module;
        if (!ENVIRONMENT_IS_PTHREAD) {
          var numWorkersToLoad = PThread.unusedWorkers.length;
          PThread.unusedWorkers.forEach(function (w) {
            PThread.loadWasmModuleToWorker(w, function () {
              if (!--numWorkersToLoad) removeRunDependency('wasm-instantiate');
            });
          });
        }
      }
      if (!ENVIRONMENT_IS_PTHREAD) {
        addRunDependency('wasm-instantiate');
      }
      function receiveInstantiationResult(result) {
        receiveInstance(result['instance'], result['module']);
      }
      function instantiateArrayBuffer(receiver) {
        return getBinaryPromise()
          .then(function (binary) {
            return WebAssembly.instantiate(binary, info);
          })
          .then(function (instance) {
            return instance;
          })
          .then(receiver, function (reason) {
            err('failed to asynchronously prepare wasm: ' + reason);
            abort(reason);
          });
      }
      function instantiateAsync() {
        if (
          !wasmBinary &&
          typeof WebAssembly.instantiateStreaming === 'function' &&
          !isDataURI(wasmBinaryFile) &&
          !isFileURI(wasmBinaryFile) &&
          typeof fetch === 'function'
        ) {
          return fetch(wasmBinaryFile, { credentials: 'same-origin' }).then(
            function (response) {
              var result = WebAssembly.instantiateStreaming(response, info);
              return result.then(receiveInstantiationResult, function (reason) {
                err('wasm streaming compile failed: ' + reason);
                err('falling back to ArrayBuffer instantiation');
                return instantiateArrayBuffer(receiveInstantiationResult);
              });
            }
          );
        } else {
          return instantiateArrayBuffer(receiveInstantiationResult);
        }
      }
      if (Module['instantiateWasm']) {
        try {
          var exports = Module['instantiateWasm'](info, receiveInstance);
          return exports;
        } catch (e) {
          err('Module.instantiateWasm callback failed with error: ' + e);
          return false;
        }
      }
      instantiateAsync().catch(readyPromiseReject);
      return {};
    }
    var ASM_CONSTS = {
      372636: function ($0) {
        if (!$0) {
          AL.alcErr = 40964;
          return 1;
        }
      },
      372684: function ($0) {
        err('bad name in alcGetProcAddress: ' + UTF8ToString($0));
      },
      372747: function ($0) {
        if (!AL.currentCtx) {
          err('alGetProcAddress() called without a valid context');
          return 1;
        }
        if (!$0) {
          AL.currentCtx.err = 40963;
          return 1;
        }
      },
      372895: function ($0) {
        err('bad name in alGetProcAddress: ' + UTF8ToString($0));
      }
    };
    function callRuntimeCallbacks(callbacks) {
      while (callbacks.length > 0) {
        var callback = callbacks.shift();
        if (typeof callback == 'function') {
          callback(Module);
          continue;
        }
        var func = callback.func;
        if (typeof func === 'number') {
          if (callback.arg === undefined) {
            wasmTable.get(func)();
          } else {
            wasmTable.get(func)(callback.arg);
          }
        } else {
          func(callback.arg === undefined ? null : callback.arg);
        }
      }
    }
    function _emscripten_futex_wake(addr, count) {
      if (addr <= 0 || addr > HEAP8.length || addr & (3 != 0) || count < 0)
        return -28;
      if (count == 0) return 0;
      if (count >= 2147483647) count = Infinity;
      var mainThreadWaitAddress = Atomics.load(
        HEAP32,
        __emscripten_main_thread_futex >> 2
      );
      var mainThreadWoken = 0;
      if (mainThreadWaitAddress == addr) {
        var loadedAddr = Atomics.compareExchange(
          HEAP32,
          __emscripten_main_thread_futex >> 2,
          mainThreadWaitAddress,
          0
        );
        if (loadedAddr == mainThreadWaitAddress) {
          --count;
          mainThreadWoken = 1;
          if (count <= 0) return 1;
        }
      }
      var ret = Atomics.notify(HEAP32, addr >> 2, count);
      if (ret >= 0) return ret + mainThreadWoken;
      throw 'Atomics.notify returned an unexpected value ' + ret;
    }
    Module['_emscripten_futex_wake'] = _emscripten_futex_wake;
    function killThread(pthread_ptr) {
      if (ENVIRONMENT_IS_PTHREAD)
        throw 'Internal Error! killThread() can only ever be called from main application thread!';
      if (!pthread_ptr) throw 'Internal Error! Null pthread_ptr in killThread!';
      HEAP32[(pthread_ptr + 8) >> 2] = 0;
      var pthread = PThread.pthreads[pthread_ptr];
      delete PThread.pthreads[pthread_ptr];
      pthread.worker.terminate();
      PThread.freeThreadData(pthread);
      PThread.runningWorkers.splice(
        PThread.runningWorkers.indexOf(pthread.worker),
        1
      );
      pthread.worker.pthread = undefined;
    }
    function cancelThread(pthread_ptr) {
      if (ENVIRONMENT_IS_PTHREAD)
        throw 'Internal Error! cancelThread() can only ever be called from main application thread!';
      if (!pthread_ptr)
        throw 'Internal Error! Null pthread_ptr in cancelThread!';
      var pthread = PThread.pthreads[pthread_ptr];
      pthread.worker.postMessage({ cmd: 'cancel' });
    }
    function cleanupThread(pthread_ptr) {
      if (ENVIRONMENT_IS_PTHREAD)
        throw 'Internal Error! cleanupThread() can only ever be called from main application thread!';
      if (!pthread_ptr)
        throw 'Internal Error! Null pthread_ptr in cleanupThread!';
      var pthread = PThread.pthreads[pthread_ptr];
      if (pthread) {
        HEAP32[(pthread_ptr + 8) >> 2] = 0;
        var worker = pthread.worker;
        PThread.returnWorkerToPool(worker);
      }
    }
    function _exit(status) {
      exit(status);
    }
    Module['_exit'] = _exit;
    function handleException(e) {
      if (e instanceof ExitStatus || e == 'unwind') {
        return EXITSTATUS;
      }
      var toLog = e;
      err('exception thrown: ' + toLog);
      quit_(1, e);
    }
    var PThread = {
      unusedWorkers: [],
      runningWorkers: [],
      tlsInitFunctions: [],
      initMainThreadBlock: function () {
        var pthreadPoolSize = 2;
        for (var i = 0; i < pthreadPoolSize; ++i) {
          PThread.allocateUnusedWorker();
        }
      },
      initWorker: function () {},
      pthreads: {},
      threadExitHandlers: [],
      setExitStatus: function (status) {
        EXITSTATUS = status;
      },
      terminateAllThreads: function () {
        for (var t in PThread.pthreads) {
          var pthread = PThread.pthreads[t];
          if (pthread && pthread.worker) {
            PThread.returnWorkerToPool(pthread.worker);
          }
        }
        PThread.pthreads = {};
        for (var i = 0; i < PThread.unusedWorkers.length; ++i) {
          var worker = PThread.unusedWorkers[i];
          worker.terminate();
        }
        PThread.unusedWorkers = [];
        for (var i = 0; i < PThread.runningWorkers.length; ++i) {
          var worker = PThread.runningWorkers[i];
          var pthread = worker.pthread;
          worker.terminate();
          PThread.freeThreadData(pthread);
        }
        PThread.runningWorkers = [];
      },
      freeThreadData: function (pthread) {
        if (!pthread) return;
        if (pthread.threadInfoStruct) {
          _free(pthread.threadInfoStruct);
        }
        pthread.threadInfoStruct = 0;
        if (pthread.allocatedOwnStack && pthread.stackBase)
          _free(pthread.stackBase);
        pthread.stackBase = 0;
        if (pthread.worker) pthread.worker.pthread = null;
      },
      returnWorkerToPool: function (worker) {
        PThread.runWithoutMainThreadQueuedCalls(function () {
          delete PThread.pthreads[worker.pthread.threadInfoStruct];
          PThread.unusedWorkers.push(worker);
          PThread.runningWorkers.splice(
            PThread.runningWorkers.indexOf(worker),
            1
          );
          PThread.freeThreadData(worker.pthread);
          worker.pthread = undefined;
        });
      },
      runWithoutMainThreadQueuedCalls: function (func) {
        HEAP32[__emscripten_allow_main_runtime_queued_calls >> 2] = 0;
        try {
          func();
        } finally {
          HEAP32[__emscripten_allow_main_runtime_queued_calls >> 2] = 1;
        }
      },
      receiveObjectTransfer: function (data) {},
      threadInit: function () {
        for (var i in PThread.tlsInitFunctions) {
          PThread.tlsInitFunctions[i]();
        }
      },
      loadWasmModuleToWorker: function (worker, onFinishedLoading) {
        worker.onmessage = function (e) {
          var d = e['data'];
          var cmd = d['cmd'];
          if (worker.pthread)
            PThread.currentProxiedOperationCallerThread =
              worker.pthread.threadInfoStruct;
          if (d['targetThread'] && d['targetThread'] != _pthread_self()) {
            var thread = PThread.pthreads[d.targetThread];
            if (thread) {
              thread.worker.postMessage(e.data, d['transferList']);
            } else {
              err(
                'Internal error! Worker sent a message "' +
                  cmd +
                  '" to target pthread ' +
                  d['targetThread'] +
                  ', but that thread no longer exists!'
              );
            }
            PThread.currentProxiedOperationCallerThread = undefined;
            return;
          }
          if (cmd === 'processQueuedMainThreadWork') {
            _emscripten_main_thread_process_queued_calls();
          } else if (cmd === 'spawnThread') {
            spawnThread(e.data);
          } else if (cmd === 'cleanupThread') {
            cleanupThread(d['thread']);
          } else if (cmd === 'killThread') {
            killThread(d['thread']);
          } else if (cmd === 'cancelThread') {
            cancelThread(d['thread']);
          } else if (cmd === 'loaded') {
            worker.loaded = true;
            if (onFinishedLoading) onFinishedLoading(worker);
            if (worker.runPthread) {
              worker.runPthread();
              delete worker.runPthread;
            }
          } else if (cmd === 'print') {
            out('Thread ' + d['threadId'] + ': ' + d['text']);
          } else if (cmd === 'printErr') {
            err('Thread ' + d['threadId'] + ': ' + d['text']);
          } else if (cmd === 'alert') {
            alert('Thread ' + d['threadId'] + ': ' + d['text']);
          } else if (cmd === 'detachedExit') {
            PThread.returnWorkerToPool(worker);
          } else if (cmd === 'exitProcess') {
            try {
              _exit(d['returnCode']);
            } catch (e) {
              handleException(e);
            }
          } else if (cmd === 'cancelDone') {
            PThread.returnWorkerToPool(worker);
          } else if (e.data.target === 'setimmediate') {
            worker.postMessage(e.data);
          } else if (cmd === 'onAbort') {
            if (Module['onAbort']) {
              Module['onAbort'](d['arg']);
            }
          } else {
            err('worker sent an unknown command ' + cmd);
          }
          PThread.currentProxiedOperationCallerThread = undefined;
        };
        worker.onerror = function (e) {
          err(
            'pthread sent an error! ' +
              e.filename +
              ':' +
              e.lineno +
              ': ' +
              e.message
          );
          throw e;
        };
        if (ENVIRONMENT_IS_NODE) {
          worker.on('message', function (data) {
            worker.onmessage({ data: data });
          });
          worker.on('error', function (e) {
            worker.onerror(e);
          });
          worker.on('detachedExit', function () {});
        }
        worker.postMessage({
          cmd: 'load',
          urlOrBlob: Module['mainScriptUrlOrBlob'] || _scriptDir,
          wasmMemory: wasmMemory,
          wasmModule: wasmModule
        });
      },
      allocateUnusedWorker: function () {
        var pthreadMainJs = locateFile('AudioInterCom.worker.js');
        PThread.unusedWorkers.push(new Worker(pthreadMainJs));
      },
      getNewWorker: function () {
        if (PThread.unusedWorkers.length == 0) {
          PThread.allocateUnusedWorker();
          PThread.loadWasmModuleToWorker(PThread.unusedWorkers[0]);
        }
        return PThread.unusedWorkers.pop();
      }
    };
    function establishStackSpace(stackTop, stackMax) {
      _emscripten_stack_set_limits(stackTop, stackMax);
      stackRestore(stackTop);
    }
    Module['establishStackSpace'] = establishStackSpace;
    function invokeEntryPoint(ptr, arg) {
      return wasmTable.get(ptr)(arg);
    }
    Module['invokeEntryPoint'] = invokeEntryPoint;
    function _CaptureDataCB(port, pCaptureData, size, nType) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          1,
          0,
          port,
          pCaptureData,
          size,
          nType
        );
      var aCaptureData = new Uint8Array(size);
      aCaptureData.set(
        Module.HEAPU8.subarray(pCaptureData, pCaptureData + size)
      );
      JSAUDIOCOM_CaptureDataCBFun(port, aCaptureData, size, nType);
      aCaptureData = null;
    }
    function _DecodeDataCB(port, pDecodeData, size, nType) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          2,
          0,
          port,
          pDecodeData,
          size,
          nType
        );
      var aDecodeData = new Uint8Array(size);
      aDecodeData.set(Module.HEAPU8.subarray(pDecodeData, pDecodeData + size));
      JSAUDIOCOM_DecodeDataCBFun(port, aDecodeData, size, nType);
      aDecodeData = null;
    }
    function _EncodeDataCB(port, pEncodeData, size, nType) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          3,
          0,
          port,
          pEncodeData,
          size,
          nType
        );
      var aEncodeData = new Uint8Array(size);
      aEncodeData.set(Module.HEAPU8.subarray(pEncodeData, pEncodeData + size));
      JSAUDIOCOM_EncodeDataCBFun(port, aEncodeData, size, nType);
      aEncodeData = null;
    }
    function _ResampleDataCB(port, pResampleData, size, nType) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          4,
          0,
          port,
          pResampleData,
          size,
          nType
        );
      var aResampleData = new Uint8Array(size);
      aResampleData.set(
        Module.HEAPU8.subarray(pResampleData, pResampleData + size)
      );
      JSAUDIOCOM_ResampleDataCBFun(port, aResampleData, size, nType);
      aResampleData = null;
    }
    function ___assert_fail(condition, filename, line, func) {
      abort(
        'Assertion failed: ' +
          UTF8ToString(condition) +
          ', at: ' +
          [
            filename ? UTF8ToString(filename) : 'unknown filename',
            line,
            func ? UTF8ToString(func) : 'unknown function'
          ]
      );
    }
    var _emscripten_get_now;
    if (ENVIRONMENT_IS_NODE) {
      _emscripten_get_now = function () {
        var t = process['hrtime']();
        return t[0] * 1e3 + t[1] / 1e6;
      };
    } else if (ENVIRONMENT_IS_PTHREAD) {
      _emscripten_get_now = function () {
        return performance.now() - Module['__performance_now_clock_drift'];
      };
    } else
      _emscripten_get_now = function () {
        return performance.now();
      };
    function ___cxa_allocate_exception(size) {
      return _malloc(size + 16) + 16;
    }
    function _atexit(func, arg) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(5, 1, func, arg);
    }
    function ___cxa_thread_atexit(routine, arg) {
      PThread.threadExitHandlers.push(function () {
        wasmTable.get(routine)(arg);
      });
    }
    function ExceptionInfo(excPtr) {
      this.excPtr = excPtr;
      this.ptr = excPtr - 16;
      this.set_type = function (type) {
        HEAP32[(this.ptr + 4) >> 2] = type;
      };
      this.get_type = function () {
        return HEAP32[(this.ptr + 4) >> 2];
      };
      this.set_destructor = function (destructor) {
        HEAP32[(this.ptr + 8) >> 2] = destructor;
      };
      this.get_destructor = function () {
        return HEAP32[(this.ptr + 8) >> 2];
      };
      this.set_refcount = function (refcount) {
        HEAP32[this.ptr >> 2] = refcount;
      };
      this.set_caught = function (caught) {
        caught = caught ? 1 : 0;
        HEAP8[(this.ptr + 12) >> 0] = caught;
      };
      this.get_caught = function () {
        return HEAP8[(this.ptr + 12) >> 0] != 0;
      };
      this.set_rethrown = function (rethrown) {
        rethrown = rethrown ? 1 : 0;
        HEAP8[(this.ptr + 13) >> 0] = rethrown;
      };
      this.get_rethrown = function () {
        return HEAP8[(this.ptr + 13) >> 0] != 0;
      };
      this.init = function (type, destructor) {
        this.set_type(type);
        this.set_destructor(destructor);
        this.set_refcount(0);
        this.set_caught(false);
        this.set_rethrown(false);
      };
      this.add_ref = function () {
        Atomics.add(HEAP32, (this.ptr + 0) >> 2, 1);
      };
      this.release_ref = function () {
        var prev = Atomics.sub(HEAP32, (this.ptr + 0) >> 2, 1);
        return prev === 1;
      };
    }
    var exceptionLast = 0;
    var uncaughtExceptionCount = 0;
    function ___cxa_throw(ptr, type, destructor) {
      var info = new ExceptionInfo(ptr);
      info.init(type, destructor);
      exceptionLast = ptr;
      uncaughtExceptionCount++;
      throw ptr;
    }
    function ___emscripten_init_main_thread_js(tb) {
      __emscripten_thread_init(tb, !ENVIRONMENT_IS_WORKER, 1);
      PThread.threadInit();
    }
    function spawnThread(threadParams) {
      if (ENVIRONMENT_IS_PTHREAD)
        throw 'Internal Error! spawnThread() can only ever be called from main application thread!';
      var worker = PThread.getNewWorker();
      if (!worker) {
        return 6;
      }
      if (worker.pthread !== undefined) throw 'Internal error!';
      if (!threadParams.pthread_ptr) throw 'Internal error, no pthread ptr!';
      PThread.runningWorkers.push(worker);
      var stackHigh = threadParams.stackBase + threadParams.stackSize;
      var pthread = (PThread.pthreads[threadParams.pthread_ptr] = {
        worker: worker,
        stackBase: threadParams.stackBase,
        stackSize: threadParams.stackSize,
        allocatedOwnStack: threadParams.allocatedOwnStack,
        threadInfoStruct: threadParams.pthread_ptr
      });
      var tis = pthread.threadInfoStruct >> 2;
      Atomics.store(HEAPU32, tis + (60 >> 2), threadParams.detached);
      Atomics.store(HEAPU32, tis + (76 >> 2), threadParams.stackSize);
      Atomics.store(HEAPU32, tis + (72 >> 2), stackHigh);
      Atomics.store(HEAPU32, tis + (100 >> 2), threadParams.stackSize);
      Atomics.store(HEAPU32, tis + ((100 + 8) >> 2), stackHigh);
      Atomics.store(HEAPU32, tis + ((100 + 12) >> 2), threadParams.detached);
      worker.pthread = pthread;
      var msg = {
        cmd: 'run',
        start_routine: threadParams.startRoutine,
        arg: threadParams.arg,
        threadInfoStruct: threadParams.pthread_ptr,
        stackBase: threadParams.stackBase,
        stackSize: threadParams.stackSize
      };
      worker.runPthread = function () {
        msg.time = performance.now();
        worker.postMessage(msg, threadParams.transferList);
      };
      if (worker.loaded) {
        worker.runPthread();
        delete worker.runPthread;
      }
      return 0;
    }
    function ___pthread_create_js(pthread_ptr, attr, start_routine, arg) {
      if (typeof SharedArrayBuffer === 'undefined') {
        err(
          'Current environment does not support SharedArrayBuffer, pthreads are not available!'
        );
        return 6;
      }
      var transferList = [];
      var error = 0;
      if (ENVIRONMENT_IS_PTHREAD && (transferList.length === 0 || error)) {
        return _emscripten_sync_run_in_main_thread_4(
          687865856,
          pthread_ptr,
          attr,
          start_routine,
          arg
        );
      }
      if (error) return error;
      var stackSize = 0;
      var stackBase = 0;
      var detached = 0;
      if (attr && attr != -1) {
        stackSize = HEAP32[attr >> 2];
        stackSize += 81920;
        stackBase = HEAP32[(attr + 8) >> 2];
        detached = HEAP32[(attr + 12) >> 2] !== 0;
      } else {
        stackSize = 2097152;
      }
      var allocatedOwnStack = stackBase == 0;
      if (allocatedOwnStack) {
        stackBase = _memalign(16, stackSize);
      } else {
        stackBase -= stackSize;
        assert(stackBase > 0);
      }
      var threadParams = {
        stackBase: stackBase,
        stackSize: stackSize,
        allocatedOwnStack: allocatedOwnStack,
        detached: detached,
        startRoutine: start_routine,
        pthread_ptr: pthread_ptr,
        arg: arg,
        transferList: transferList
      };
      if (ENVIRONMENT_IS_PTHREAD) {
        threadParams.cmd = 'spawnThread';
        postMessage(threadParams, transferList);
        return 0;
      }
      return spawnThread(threadParams);
    }
    function ___pthread_detached_exit() {
      postMessage({ cmd: 'detachedExit' });
    }
    function ___pthread_exit_run_handlers(status) {
      while (PThread.threadExitHandlers.length > 0) {
        PThread.threadExitHandlers.pop()();
      }
    }
    function _emscripten_futex_wait(addr, val, timeout) {
      if (addr <= 0 || addr > HEAP8.length || addr & (3 != 0)) return -28;
      if (!ENVIRONMENT_IS_WEB) {
        var ret = Atomics.wait(HEAP32, addr >> 2, val, timeout);
        if (ret === 'timed-out') return -73;
        if (ret === 'not-equal') return -6;
        if (ret === 'ok') return 0;
        throw 'Atomics.wait returned an unexpected value ' + ret;
      } else {
        if (Atomics.load(HEAP32, addr >> 2) != val) {
          return -6;
        }
        var tNow = performance.now();
        var tEnd = tNow + timeout;
        var lastAddr = Atomics.exchange(
          HEAP32,
          __emscripten_main_thread_futex >> 2,
          addr
        );
        while (1) {
          tNow = performance.now();
          if (tNow > tEnd) {
            lastAddr = Atomics.exchange(
              HEAP32,
              __emscripten_main_thread_futex >> 2,
              0
            );
            return -73;
          }
          lastAddr = Atomics.exchange(
            HEAP32,
            __emscripten_main_thread_futex >> 2,
            0
          );
          if (lastAddr == 0) {
            break;
          }
          _emscripten_main_thread_process_queued_calls();
          if (Atomics.load(HEAP32, addr >> 2) != val) {
            return -6;
          }
          lastAddr = Atomics.exchange(
            HEAP32,
            __emscripten_main_thread_futex >> 2,
            addr
          );
        }
        return 0;
      }
    }
    function _emscripten_check_blocking_allowed() {
      if (ENVIRONMENT_IS_NODE) return;
      if (ENVIRONMENT_IS_WORKER) return;
      warnOnce(
        'Blocking on the main thread is very dangerous, see https://emscripten.org/docs/porting/pthreads.html#blocking-on-the-main-browser-thread'
      );
    }
    function __emscripten_do_pthread_join(thread, status, block) {
      if (!thread) {
        err('pthread_join attempted on a null thread pointer!');
        return 71;
      }
      if (ENVIRONMENT_IS_PTHREAD && _pthread_self() == thread) {
        err('PThread ' + thread + ' is attempting to join to itself!');
        return 16;
      } else if (
        !ENVIRONMENT_IS_PTHREAD &&
        _emscripten_main_browser_thread_id() == thread
      ) {
        err('Main thread ' + thread + ' is attempting to join to itself!');
        return 16;
      }
      var self = HEAP32[(thread + 8) >> 2];
      if (self !== thread) {
        err(
          'pthread_join attempted on thread ' +
            thread +
            ', which does not point to a valid thread, or does not exist anymore!'
        );
        return 71;
      }
      var detached = Atomics.load(HEAPU32, (thread + 60) >> 2);
      if (detached) {
        err(
          'Attempted to join thread ' + thread + ', which was already detached!'
        );
        return 28;
      }
      if (block) {
        _emscripten_check_blocking_allowed();
      }
      for (;;) {
        var threadStatus = Atomics.load(HEAPU32, (thread + 0) >> 2);
        if (threadStatus == 1) {
          if (status) {
            var result = Atomics.load(HEAPU32, (thread + 88) >> 2);
            HEAP32[status >> 2] = result;
          }
          Atomics.store(HEAPU32, (thread + 60) >> 2, 1);
          if (!ENVIRONMENT_IS_PTHREAD) cleanupThread(thread);
          else postMessage({ cmd: 'cleanupThread', thread: thread });
          return 0;
        }
        if (!block) {
          return 10;
        }
        _pthread_testcancel();
        if (!ENVIRONMENT_IS_PTHREAD)
          _emscripten_main_thread_process_queued_calls();
        _emscripten_futex_wait(
          thread + 0,
          threadStatus,
          ENVIRONMENT_IS_PTHREAD ? 100 : 1
        );
      }
    }
    function ___pthread_join_js(thread, status) {
      return __emscripten_do_pthread_join(thread, status, true);
    }
    var structRegistrations = {};
    function runDestructors(destructors) {
      while (destructors.length) {
        var ptr = destructors.pop();
        var del = destructors.pop();
        del(ptr);
      }
    }
    function simpleReadValueFromPointer(pointer) {
      return this['fromWireType'](HEAPU32[pointer >> 2]);
    }
    var awaitingDependencies = {};
    var registeredTypes = {};
    var typeDependencies = {};
    var char_0 = 48;
    var char_9 = 57;
    function makeLegalFunctionName(name) {
      if (undefined === name) {
        return '_unknown';
      }
      name = name.replace(/[^a-zA-Z0-9_]/g, '$');
      var f = name.charCodeAt(0);
      if (f >= char_0 && f <= char_9) {
        return '_' + name;
      } else {
        return name;
      }
    }
    function createNamedFunction(name, body) {
      name = makeLegalFunctionName(name);
      return new Function(
        'body',
        'return function ' +
          name +
          '() {\n' +
          '    "use strict";' +
          '    return body.apply(this, arguments);\n' +
          '};\n'
      )(body);
    }
    function extendError(baseErrorType, errorName) {
      var errorClass = createNamedFunction(errorName, function (message) {
        this.name = errorName;
        this.message = message;
        var stack = new Error(message).stack;
        if (stack !== undefined) {
          this.stack =
            this.toString() + '\n' + stack.replace(/^Error(:[^\n]*)?\n/, '');
        }
      });
      errorClass.prototype = Object.create(baseErrorType.prototype);
      errorClass.prototype.constructor = errorClass;
      errorClass.prototype.toString = function () {
        if (this.message === undefined) {
          return this.name;
        } else {
          return this.name + ': ' + this.message;
        }
      };
      return errorClass;
    }
    var InternalError = undefined;
    function throwInternalError(message) {
      throw new InternalError(message);
    }
    function whenDependentTypesAreResolved(
      myTypes,
      dependentTypes,
      getTypeConverters
    ) {
      myTypes.forEach(function (type) {
        typeDependencies[type] = dependentTypes;
      });
      function onComplete(typeConverters) {
        var myTypeConverters = getTypeConverters(typeConverters);
        if (myTypeConverters.length !== myTypes.length) {
          throwInternalError('Mismatched type converter count');
        }
        for (var i = 0; i < myTypes.length; ++i) {
          registerType(myTypes[i], myTypeConverters[i]);
        }
      }
      var typeConverters = new Array(dependentTypes.length);
      var unregisteredTypes = [];
      var registered = 0;
      dependentTypes.forEach(function (dt, i) {
        if (registeredTypes.hasOwnProperty(dt)) {
          typeConverters[i] = registeredTypes[dt];
        } else {
          unregisteredTypes.push(dt);
          if (!awaitingDependencies.hasOwnProperty(dt)) {
            awaitingDependencies[dt] = [];
          }
          awaitingDependencies[dt].push(function () {
            typeConverters[i] = registeredTypes[dt];
            ++registered;
            if (registered === unregisteredTypes.length) {
              onComplete(typeConverters);
            }
          });
        }
      });
      if (0 === unregisteredTypes.length) {
        onComplete(typeConverters);
      }
    }
    function __embind_finalize_value_object(structType) {
      var reg = structRegistrations[structType];
      delete structRegistrations[structType];
      var rawConstructor = reg.rawConstructor;
      var rawDestructor = reg.rawDestructor;
      var fieldRecords = reg.fields;
      var fieldTypes = fieldRecords
        .map(function (field) {
          return field.getterReturnType;
        })
        .concat(
          fieldRecords.map(function (field) {
            return field.setterArgumentType;
          })
        );
      whenDependentTypesAreResolved(
        [structType],
        fieldTypes,
        function (fieldTypes) {
          var fields = {};
          fieldRecords.forEach(function (field, i) {
            var fieldName = field.fieldName;
            var getterReturnType = fieldTypes[i];
            var getter = field.getter;
            var getterContext = field.getterContext;
            var setterArgumentType = fieldTypes[i + fieldRecords.length];
            var setter = field.setter;
            var setterContext = field.setterContext;
            fields[fieldName] = {
              read: function (ptr) {
                return getterReturnType['fromWireType'](
                  getter(getterContext, ptr)
                );
              },
              write: function (ptr, o) {
                var destructors = [];
                setter(
                  setterContext,
                  ptr,
                  setterArgumentType['toWireType'](destructors, o)
                );
                runDestructors(destructors);
              }
            };
          });
          return [
            {
              name: reg.name,
              fromWireType: function (ptr) {
                var rv = {};
                for (var i in fields) {
                  rv[i] = fields[i].read(ptr);
                }
                rawDestructor(ptr);
                return rv;
              },
              toWireType: function (destructors, o) {
                for (var fieldName in fields) {
                  if (!(fieldName in o)) {
                    throw new TypeError('Missing field:  "' + fieldName + '"');
                  }
                }
                var ptr = rawConstructor();
                for (fieldName in fields) {
                  fields[fieldName].write(ptr, o[fieldName]);
                }
                if (destructors !== null) {
                  destructors.push(rawDestructor, ptr);
                }
                return ptr;
              },
              argPackAdvance: 8,
              readValueFromPointer: simpleReadValueFromPointer,
              destructorFunction: rawDestructor
            }
          ];
        }
      );
    }
    function __embind_register_bigint(
      primitiveType,
      name,
      size,
      minRange,
      maxRange
    ) {}
    function getShiftFromSize(size) {
      switch (size) {
        case 1:
          return 0;
        case 2:
          return 1;
        case 4:
          return 2;
        case 8:
          return 3;
        default:
          throw new TypeError('Unknown type size: ' + size);
      }
    }
    function embind_init_charCodes() {
      var codes = new Array(256);
      for (var i = 0; i < 256; ++i) {
        codes[i] = String.fromCharCode(i);
      }
      embind_charCodes = codes;
    }
    var embind_charCodes = undefined;
    function readLatin1String(ptr) {
      var ret = '';
      var c = ptr;
      while (HEAPU8[c]) {
        ret += embind_charCodes[HEAPU8[c++]];
      }
      return ret;
    }
    var BindingError = undefined;
    function throwBindingError(message) {
      throw new BindingError(message);
    }
    function registerType(rawType, registeredInstance, options) {
      options = options || {};
      if (!('argPackAdvance' in registeredInstance)) {
        throw new TypeError(
          'registerType registeredInstance requires argPackAdvance'
        );
      }
      var name = registeredInstance.name;
      if (!rawType) {
        throwBindingError(
          'type "' + name + '" must have a positive integer typeid pointer'
        );
      }
      if (registeredTypes.hasOwnProperty(rawType)) {
        if (options.ignoreDuplicateRegistrations) {
          return;
        } else {
          throwBindingError("Cannot register type '" + name + "' twice");
        }
      }
      registeredTypes[rawType] = registeredInstance;
      delete typeDependencies[rawType];
      if (awaitingDependencies.hasOwnProperty(rawType)) {
        var callbacks = awaitingDependencies[rawType];
        delete awaitingDependencies[rawType];
        callbacks.forEach(function (cb) {
          cb();
        });
      }
    }
    function __embind_register_bool(
      rawType,
      name,
      size,
      trueValue,
      falseValue
    ) {
      var shift = getShiftFromSize(size);
      name = readLatin1String(name);
      registerType(rawType, {
        name: name,
        fromWireType: function (wt) {
          return !!wt;
        },
        toWireType: function (destructors, o) {
          return o ? trueValue : falseValue;
        },
        argPackAdvance: 8,
        readValueFromPointer: function (pointer) {
          var heap;
          if (size === 1) {
            heap = HEAP8;
          } else if (size === 2) {
            heap = HEAP16;
          } else if (size === 4) {
            heap = HEAP32;
          } else {
            throw new TypeError('Unknown boolean type size: ' + name);
          }
          return this['fromWireType'](heap[pointer >> shift]);
        },
        destructorFunction: null
      });
    }
    var emval_free_list = [];
    var emval_handle_array = [
      {},
      { value: undefined },
      { value: null },
      { value: true },
      { value: false }
    ];
    function __emval_decref(handle) {
      if (handle > 4 && 0 === --emval_handle_array[handle].refcount) {
        emval_handle_array[handle] = undefined;
        emval_free_list.push(handle);
      }
    }
    function count_emval_handles() {
      var count = 0;
      for (var i = 5; i < emval_handle_array.length; ++i) {
        if (emval_handle_array[i] !== undefined) {
          ++count;
        }
      }
      return count;
    }
    function get_first_emval() {
      for (var i = 5; i < emval_handle_array.length; ++i) {
        if (emval_handle_array[i] !== undefined) {
          return emval_handle_array[i];
        }
      }
      return null;
    }
    function init_emval() {
      Module['count_emval_handles'] = count_emval_handles;
      Module['get_first_emval'] = get_first_emval;
    }
    function __emval_register(value) {
      switch (value) {
        case undefined: {
          return 1;
        }
        case null: {
          return 2;
        }
        case true: {
          return 3;
        }
        case false: {
          return 4;
        }
        default: {
          var handle = emval_free_list.length
            ? emval_free_list.pop()
            : emval_handle_array.length;
          emval_handle_array[handle] = { refcount: 1, value: value };
          return handle;
        }
      }
    }
    function __embind_register_emval(rawType, name) {
      name = readLatin1String(name);
      registerType(rawType, {
        name: name,
        fromWireType: function (handle) {
          var rv = emval_handle_array[handle].value;
          __emval_decref(handle);
          return rv;
        },
        toWireType: function (destructors, value) {
          return __emval_register(value);
        },
        argPackAdvance: 8,
        readValueFromPointer: simpleReadValueFromPointer,
        destructorFunction: null
      });
    }
    function _embind_repr(v) {
      if (v === null) {
        return 'null';
      }
      var t = typeof v;
      if (t === 'object' || t === 'array' || t === 'function') {
        return v.toString();
      } else {
        return '' + v;
      }
    }
    function floatReadValueFromPointer(name, shift) {
      switch (shift) {
        case 2:
          return function (pointer) {
            return this['fromWireType'](HEAPF32[pointer >> 2]);
          };
        case 3:
          return function (pointer) {
            return this['fromWireType'](HEAPF64[pointer >> 3]);
          };
        default:
          throw new TypeError('Unknown float type: ' + name);
      }
    }
    function __embind_register_float(rawType, name, size) {
      var shift = getShiftFromSize(size);
      name = readLatin1String(name);
      registerType(rawType, {
        name: name,
        fromWireType: function (value) {
          return value;
        },
        toWireType: function (destructors, value) {
          if (typeof value !== 'number' && typeof value !== 'boolean') {
            throw new TypeError(
              'Cannot convert "' + _embind_repr(value) + '" to ' + this.name
            );
          }
          return value;
        },
        argPackAdvance: 8,
        readValueFromPointer: floatReadValueFromPointer(name, shift),
        destructorFunction: null
      });
    }
    function new_(constructor, argumentList) {
      if (!(constructor instanceof Function)) {
        throw new TypeError(
          'new_ called with constructor type ' +
            typeof constructor +
            ' which is not a function'
        );
      }
      var dummy = createNamedFunction(
        constructor.name || 'unknownFunctionName',
        function () {}
      );
      dummy.prototype = constructor.prototype;
      var obj = new dummy();
      var r = constructor.apply(obj, argumentList);
      return r instanceof Object ? r : obj;
    }
    function craftInvokerFunction(
      humanName,
      argTypes,
      classType,
      cppInvokerFunc,
      cppTargetFunc
    ) {
      var argCount = argTypes.length;
      if (argCount < 2) {
        throwBindingError(
          "argTypes array size mismatch! Must at least get return value and 'this' types!"
        );
      }
      var isClassMethodFunc = argTypes[1] !== null && classType !== null;
      var needsDestructorStack = false;
      for (var i = 1; i < argTypes.length; ++i) {
        if (
          argTypes[i] !== null &&
          argTypes[i].destructorFunction === undefined
        ) {
          needsDestructorStack = true;
          break;
        }
      }
      var returns = argTypes[0].name !== 'void';
      var argsList = '';
      var argsListWired = '';
      for (var i = 0; i < argCount - 2; ++i) {
        argsList += (i !== 0 ? ', ' : '') + 'arg' + i;
        argsListWired += (i !== 0 ? ', ' : '') + 'arg' + i + 'Wired';
      }
      var invokerFnBody =
        'return function ' +
        makeLegalFunctionName(humanName) +
        '(' +
        argsList +
        ') {\n' +
        'if (arguments.length !== ' +
        (argCount - 2) +
        ') {\n' +
        "throwBindingError('function " +
        humanName +
        " called with ' + arguments.length + ' arguments, expected " +
        (argCount - 2) +
        " args!');\n" +
        '}\n';
      if (needsDestructorStack) {
        invokerFnBody += 'var destructors = [];\n';
      }
      var dtorStack = needsDestructorStack ? 'destructors' : 'null';
      var args1 = [
        'throwBindingError',
        'invoker',
        'fn',
        'runDestructors',
        'retType',
        'classParam'
      ];
      var args2 = [
        throwBindingError,
        cppInvokerFunc,
        cppTargetFunc,
        runDestructors,
        argTypes[0],
        argTypes[1]
      ];
      if (isClassMethodFunc) {
        invokerFnBody +=
          'var thisWired = classParam.toWireType(' + dtorStack + ', this);\n';
      }
      for (var i = 0; i < argCount - 2; ++i) {
        invokerFnBody +=
          'var arg' +
          i +
          'Wired = argType' +
          i +
          '.toWireType(' +
          dtorStack +
          ', arg' +
          i +
          '); // ' +
          argTypes[i + 2].name +
          '\n';
        args1.push('argType' + i);
        args2.push(argTypes[i + 2]);
      }
      if (isClassMethodFunc) {
        argsListWired =
          'thisWired' + (argsListWired.length > 0 ? ', ' : '') + argsListWired;
      }
      invokerFnBody +=
        (returns ? 'var rv = ' : '') +
        'invoker(fn' +
        (argsListWired.length > 0 ? ', ' : '') +
        argsListWired +
        ');\n';
      if (needsDestructorStack) {
        invokerFnBody += 'runDestructors(destructors);\n';
      } else {
        for (var i = isClassMethodFunc ? 1 : 2; i < argTypes.length; ++i) {
          var paramName = i === 1 ? 'thisWired' : 'arg' + (i - 2) + 'Wired';
          if (argTypes[i].destructorFunction !== null) {
            invokerFnBody +=
              paramName +
              '_dtor(' +
              paramName +
              '); // ' +
              argTypes[i].name +
              '\n';
            args1.push(paramName + '_dtor');
            args2.push(argTypes[i].destructorFunction);
          }
        }
      }
      if (returns) {
        invokerFnBody +=
          'var ret = retType.fromWireType(rv);\n' + 'return ret;\n';
      } else {
      }
      invokerFnBody += '}\n';
      args1.push(invokerFnBody);
      var invokerFunction = new_(Function, args1).apply(null, args2);
      return invokerFunction;
    }
    function ensureOverloadTable(proto, methodName, humanName) {
      if (undefined === proto[methodName].overloadTable) {
        var prevFunc = proto[methodName];
        proto[methodName] = function () {
          if (
            !proto[methodName].overloadTable.hasOwnProperty(arguments.length)
          ) {
            throwBindingError(
              "Function '" +
                humanName +
                "' called with an invalid number of arguments (" +
                arguments.length +
                ') - expects one of (' +
                proto[methodName].overloadTable +
                ')!'
            );
          }
          return proto[methodName].overloadTable[arguments.length].apply(
            this,
            arguments
          );
        };
        proto[methodName].overloadTable = [];
        proto[methodName].overloadTable[prevFunc.argCount] = prevFunc;
      }
    }
    function exposePublicSymbol(name, value, numArguments) {
      if (Module.hasOwnProperty(name)) {
        if (
          undefined === numArguments ||
          (undefined !== Module[name].overloadTable &&
            undefined !== Module[name].overloadTable[numArguments])
        ) {
          throwBindingError("Cannot register public name '" + name + "' twice");
        }
        ensureOverloadTable(Module, name, name);
        if (Module.hasOwnProperty(numArguments)) {
          throwBindingError(
            'Cannot register multiple overloads of a function with the same number of arguments (' +
              numArguments +
              ')!'
          );
        }
        Module[name].overloadTable[numArguments] = value;
      } else {
        Module[name] = value;
        if (undefined !== numArguments) {
          Module[name].numArguments = numArguments;
        }
      }
    }
    function heap32VectorToArray(count, firstElement) {
      var array = [];
      for (var i = 0; i < count; i++) {
        array.push(HEAP32[(firstElement >> 2) + i]);
      }
      return array;
    }
    function replacePublicSymbol(name, value, numArguments) {
      if (!Module.hasOwnProperty(name)) {
        throwInternalError('Replacing nonexistant public symbol');
      }
      if (
        undefined !== Module[name].overloadTable &&
        undefined !== numArguments
      ) {
        Module[name].overloadTable[numArguments] = value;
      } else {
        Module[name] = value;
        Module[name].argCount = numArguments;
      }
    }
    function dynCallLegacy(sig, ptr, args) {
      var f = Module['dynCall_' + sig];
      return args && args.length
        ? f.apply(null, [ptr].concat(args))
        : f.call(null, ptr);
    }
    function dynCall(sig, ptr, args) {
      if (sig.includes('j')) {
        return dynCallLegacy(sig, ptr, args);
      }
      return wasmTable.get(ptr).apply(null, args);
    }
    function getDynCaller(sig, ptr) {
      var argCache = [];
      return function () {
        argCache.length = arguments.length;
        for (var i = 0; i < arguments.length; i++) {
          argCache[i] = arguments[i];
        }
        return dynCall(sig, ptr, argCache);
      };
    }
    function embind__requireFunction(signature, rawFunction) {
      signature = readLatin1String(signature);
      function makeDynCaller() {
        if (signature.includes('j')) {
          return getDynCaller(signature, rawFunction);
        }
        return wasmTable.get(rawFunction);
      }
      var fp = makeDynCaller();
      if (typeof fp !== 'function') {
        throwBindingError(
          'unknown function pointer with signature ' +
            signature +
            ': ' +
            rawFunction
        );
      }
      return fp;
    }
    var UnboundTypeError = undefined;
    function getTypeName(type) {
      var ptr = ___getTypeName(type);
      var rv = readLatin1String(ptr);
      _free(ptr);
      return rv;
    }
    function throwUnboundTypeError(message, types) {
      var unboundTypes = [];
      var seen = {};
      function visit(type) {
        if (seen[type]) {
          return;
        }
        if (registeredTypes[type]) {
          return;
        }
        if (typeDependencies[type]) {
          typeDependencies[type].forEach(visit);
          return;
        }
        unboundTypes.push(type);
        seen[type] = true;
      }
      types.forEach(visit);
      throw new UnboundTypeError(
        message + ': ' + unboundTypes.map(getTypeName).join([', '])
      );
    }
    function __embind_register_function(
      name,
      argCount,
      rawArgTypesAddr,
      signature,
      rawInvoker,
      fn
    ) {
      var argTypes = heap32VectorToArray(argCount, rawArgTypesAddr);
      name = readLatin1String(name);
      rawInvoker = embind__requireFunction(signature, rawInvoker);
      exposePublicSymbol(
        name,
        function () {
          throwUnboundTypeError(
            'Cannot call ' + name + ' due to unbound types',
            argTypes
          );
        },
        argCount - 1
      );
      whenDependentTypesAreResolved([], argTypes, function (argTypes) {
        var invokerArgsArray = [argTypes[0], null].concat(argTypes.slice(1));
        replacePublicSymbol(
          name,
          craftInvokerFunction(name, invokerArgsArray, null, rawInvoker, fn),
          argCount - 1
        );
        return [];
      });
    }
    function integerReadValueFromPointer(name, shift, signed) {
      switch (shift) {
        case 0:
          return signed
            ? function readS8FromPointer(pointer) {
                return HEAP8[pointer];
              }
            : function readU8FromPointer(pointer) {
                return HEAPU8[pointer];
              };
        case 1:
          return signed
            ? function readS16FromPointer(pointer) {
                return HEAP16[pointer >> 1];
              }
            : function readU16FromPointer(pointer) {
                return HEAPU16[pointer >> 1];
              };
        case 2:
          return signed
            ? function readS32FromPointer(pointer) {
                return HEAP32[pointer >> 2];
              }
            : function readU32FromPointer(pointer) {
                return HEAPU32[pointer >> 2];
              };
        default:
          throw new TypeError('Unknown integer type: ' + name);
      }
    }
    function __embind_register_integer(
      primitiveType,
      name,
      size,
      minRange,
      maxRange
    ) {
      name = readLatin1String(name);
      if (maxRange === -1) {
        maxRange = 4294967295;
      }
      var shift = getShiftFromSize(size);
      var fromWireType = function (value) {
        return value;
      };
      if (minRange === 0) {
        var bitshift = 32 - 8 * size;
        fromWireType = function (value) {
          return (value << bitshift) >>> bitshift;
        };
      }
      var isUnsignedType = name.includes('unsigned');
      registerType(primitiveType, {
        name: name,
        fromWireType: fromWireType,
        toWireType: function (destructors, value) {
          if (typeof value !== 'number' && typeof value !== 'boolean') {
            throw new TypeError(
              'Cannot convert "' + _embind_repr(value) + '" to ' + this.name
            );
          }
          if (value < minRange || value > maxRange) {
            throw new TypeError(
              'Passing a number "' +
                _embind_repr(value) +
                '" from JS side to C/C++ side to an argument of type "' +
                name +
                '", which is outside the valid range [' +
                minRange +
                ', ' +
                maxRange +
                ']!'
            );
          }
          return isUnsignedType ? value >>> 0 : value | 0;
        },
        argPackAdvance: 8,
        readValueFromPointer: integerReadValueFromPointer(
          name,
          shift,
          minRange !== 0
        ),
        destructorFunction: null
      });
    }
    function __embind_register_memory_view(rawType, dataTypeIndex, name) {
      var typeMapping = [
        Int8Array,
        Uint8Array,
        Int16Array,
        Uint16Array,
        Int32Array,
        Uint32Array,
        Float32Array,
        Float64Array
      ];
      var TA = typeMapping[dataTypeIndex];
      function decodeMemoryView(handle) {
        handle = handle >> 2;
        var heap = HEAPU32;
        var size = heap[handle];
        var data = heap[handle + 1];
        return new TA(buffer, data, size);
      }
      name = readLatin1String(name);
      registerType(
        rawType,
        {
          name: name,
          fromWireType: decodeMemoryView,
          argPackAdvance: 8,
          readValueFromPointer: decodeMemoryView
        },
        { ignoreDuplicateRegistrations: true }
      );
    }
    function __embind_register_std_string(rawType, name) {
      name = readLatin1String(name);
      var stdStringIsUTF8 = name === 'std::string';
      registerType(rawType, {
        name: name,
        fromWireType: function (value) {
          var length = HEAPU32[value >> 2];
          var str;
          if (stdStringIsUTF8) {
            var decodeStartPtr = value + 4;
            for (var i = 0; i <= length; ++i) {
              var currentBytePtr = value + 4 + i;
              if (i == length || HEAPU8[currentBytePtr] == 0) {
                var maxRead = currentBytePtr - decodeStartPtr;
                var stringSegment = UTF8ToString(decodeStartPtr, maxRead);
                if (str === undefined) {
                  str = stringSegment;
                } else {
                  str += String.fromCharCode(0);
                  str += stringSegment;
                }
                decodeStartPtr = currentBytePtr + 1;
              }
            }
          } else {
            var a = new Array(length);
            for (var i = 0; i < length; ++i) {
              a[i] = String.fromCharCode(HEAPU8[value + 4 + i]);
            }
            str = a.join('');
          }
          _free(value);
          return str;
        },
        toWireType: function (destructors, value) {
          if (value instanceof ArrayBuffer) {
            value = new Uint8Array(value);
          }
          var getLength;
          var valueIsOfTypeString = typeof value === 'string';
          if (
            !(
              valueIsOfTypeString ||
              value instanceof Uint8Array ||
              value instanceof Uint8ClampedArray ||
              value instanceof Int8Array
            )
          ) {
            throwBindingError('Cannot pass non-string to std::string');
          }
          if (stdStringIsUTF8 && valueIsOfTypeString) {
            getLength = function () {
              return lengthBytesUTF8(value);
            };
          } else {
            getLength = function () {
              return value.length;
            };
          }
          var length = getLength();
          var ptr = _malloc(4 + length + 1);
          HEAPU32[ptr >> 2] = length;
          if (stdStringIsUTF8 && valueIsOfTypeString) {
            stringToUTF8(value, ptr + 4, length + 1);
          } else {
            if (valueIsOfTypeString) {
              for (var i = 0; i < length; ++i) {
                var charCode = value.charCodeAt(i);
                if (charCode > 255) {
                  _free(ptr);
                  throwBindingError(
                    'String has UTF-16 code units that do not fit in 8 bits'
                  );
                }
                HEAPU8[ptr + 4 + i] = charCode;
              }
            } else {
              for (var i = 0; i < length; ++i) {
                HEAPU8[ptr + 4 + i] = value[i];
              }
            }
          }
          if (destructors !== null) {
            destructors.push(_free, ptr);
          }
          return ptr;
        },
        argPackAdvance: 8,
        readValueFromPointer: simpleReadValueFromPointer,
        destructorFunction: function (ptr) {
          _free(ptr);
        }
      });
    }
    function __embind_register_std_wstring(rawType, charSize, name) {
      name = readLatin1String(name);
      var decodeString, encodeString, getHeap, lengthBytesUTF, shift;
      if (charSize === 2) {
        decodeString = UTF16ToString;
        encodeString = stringToUTF16;
        lengthBytesUTF = lengthBytesUTF16;
        getHeap = function () {
          return HEAPU16;
        };
        shift = 1;
      } else if (charSize === 4) {
        decodeString = UTF32ToString;
        encodeString = stringToUTF32;
        lengthBytesUTF = lengthBytesUTF32;
        getHeap = function () {
          return HEAPU32;
        };
        shift = 2;
      }
      registerType(rawType, {
        name: name,
        fromWireType: function (value) {
          var length = HEAPU32[value >> 2];
          var HEAP = getHeap();
          var str;
          var decodeStartPtr = value + 4;
          for (var i = 0; i <= length; ++i) {
            var currentBytePtr = value + 4 + i * charSize;
            if (i == length || HEAP[currentBytePtr >> shift] == 0) {
              var maxReadBytes = currentBytePtr - decodeStartPtr;
              var stringSegment = decodeString(decodeStartPtr, maxReadBytes);
              if (str === undefined) {
                str = stringSegment;
              } else {
                str += String.fromCharCode(0);
                str += stringSegment;
              }
              decodeStartPtr = currentBytePtr + charSize;
            }
          }
          _free(value);
          return str;
        },
        toWireType: function (destructors, value) {
          if (!(typeof value === 'string')) {
            throwBindingError(
              'Cannot pass non-string to C++ string type ' + name
            );
          }
          var length = lengthBytesUTF(value);
          var ptr = _malloc(4 + length + charSize);
          HEAPU32[ptr >> 2] = length >> shift;
          encodeString(value, ptr + 4, length + charSize);
          if (destructors !== null) {
            destructors.push(_free, ptr);
          }
          return ptr;
        },
        argPackAdvance: 8,
        readValueFromPointer: simpleReadValueFromPointer,
        destructorFunction: function (ptr) {
          _free(ptr);
        }
      });
    }
    function __embind_register_value_object(
      rawType,
      name,
      constructorSignature,
      rawConstructor,
      destructorSignature,
      rawDestructor
    ) {
      structRegistrations[rawType] = {
        name: readLatin1String(name),
        rawConstructor: embind__requireFunction(
          constructorSignature,
          rawConstructor
        ),
        rawDestructor: embind__requireFunction(
          destructorSignature,
          rawDestructor
        ),
        fields: []
      };
    }
    function __embind_register_value_object_field(
      structType,
      fieldName,
      getterReturnType,
      getterSignature,
      getter,
      getterContext,
      setterArgumentType,
      setterSignature,
      setter,
      setterContext
    ) {
      structRegistrations[structType].fields.push({
        fieldName: readLatin1String(fieldName),
        getterReturnType: getterReturnType,
        getter: embind__requireFunction(getterSignature, getter),
        getterContext: getterContext,
        setterArgumentType: setterArgumentType,
        setter: embind__requireFunction(setterSignature, setter),
        setterContext: setterContext
      });
    }
    function __embind_register_void(rawType, name) {
      name = readLatin1String(name);
      registerType(rawType, {
        isVoid: true,
        name: name,
        argPackAdvance: 0,
        fromWireType: function () {
          return undefined;
        },
        toWireType: function (destructors, o) {
          return undefined;
        }
      });
    }
    function __emscripten_notify_thread_queue(targetThreadId, mainThreadId) {
      if (targetThreadId == mainThreadId) {
        postMessage({ cmd: 'processQueuedMainThreadWork' });
      } else if (ENVIRONMENT_IS_PTHREAD) {
        postMessage({
          targetThread: targetThreadId,
          cmd: 'processThreadQueue'
        });
      } else {
        var pthread = PThread.pthreads[targetThreadId];
        var worker = pthread && pthread.worker;
        if (!worker) {
          return;
        }
        worker.postMessage({ cmd: 'processThreadQueue' });
      }
      return 1;
    }
    function _emscripten_set_main_loop_timing(mode, value) {
      Browser.mainLoop.timingMode = mode;
      Browser.mainLoop.timingValue = value;
      if (!Browser.mainLoop.func) {
        return 1;
      }
      if (!Browser.mainLoop.running) {
        runtimeKeepalivePush();
        Browser.mainLoop.running = true;
      }
      if (mode == 0) {
        Browser.mainLoop.scheduler =
          function Browser_mainLoop_scheduler_setTimeout() {
            var timeUntilNextTick =
              Math.max(
                0,
                Browser.mainLoop.tickStartTime + value - _emscripten_get_now()
              ) | 0;
            setTimeout(Browser.mainLoop.runner, timeUntilNextTick);
          };
        Browser.mainLoop.method = 'timeout';
      } else if (mode == 1) {
        Browser.mainLoop.scheduler = function Browser_mainLoop_scheduler_rAF() {
          Browser.requestAnimationFrame(Browser.mainLoop.runner);
        };
        Browser.mainLoop.method = 'rAF';
      } else if (mode == 2) {
        if (typeof setImmediate === 'undefined') {
          var setImmediates = [];
          var emscriptenMainLoopMessageId = 'setimmediate';
          var Browser_setImmediate_messageHandler = function (event) {
            if (
              event.data === emscriptenMainLoopMessageId ||
              event.data.target === emscriptenMainLoopMessageId
            ) {
              event.stopPropagation();
              setImmediates.shift()();
            }
          };
          addEventListener(
            'message',
            Browser_setImmediate_messageHandler,
            true
          );
          setImmediate = function Browser_emulated_setImmediate(func) {
            setImmediates.push(func);
            if (ENVIRONMENT_IS_WORKER) {
              if (Module['setImmediates'] === undefined)
                Module['setImmediates'] = [];
              Module['setImmediates'].push(func);
              postMessage({ target: emscriptenMainLoopMessageId });
            } else postMessage(emscriptenMainLoopMessageId, '*');
          };
        }
        Browser.mainLoop.scheduler =
          function Browser_mainLoop_scheduler_setImmediate() {
            setImmediate(Browser.mainLoop.runner);
          };
        Browser.mainLoop.method = 'immediate';
      }
      return 0;
    }
    function runtimeKeepalivePush() {
      runtimeKeepaliveCounter += 1;
    }
    function maybeExit() {
      if (!keepRuntimeAlive()) {
        try {
          if (ENVIRONMENT_IS_PTHREAD) __emscripten_thread_exit(EXITSTATUS);
          else _exit(EXITSTATUS);
        } catch (e) {
          handleException(e);
        }
      }
    }
    function setMainLoop(
      browserIterationFunc,
      fps,
      simulateInfiniteLoop,
      arg,
      noSetTiming
    ) {
      assert(
        !Browser.mainLoop.func,
        'emscripten_set_main_loop: there can only be one main loop function at once: call emscripten_cancel_main_loop to cancel the previous one before setting a new one with different parameters.'
      );
      Browser.mainLoop.func = browserIterationFunc;
      Browser.mainLoop.arg = arg;
      var thisMainLoopId = Browser.mainLoop.currentlyRunningMainloop;
      function checkIsRunning() {
        if (thisMainLoopId < Browser.mainLoop.currentlyRunningMainloop) {
          runtimeKeepalivePop();
          maybeExit();
          return false;
        }
        return true;
      }
      Browser.mainLoop.running = false;
      Browser.mainLoop.runner = function Browser_mainLoop_runner() {
        if (ABORT) return;
        if (Browser.mainLoop.queue.length > 0) {
          var start = Date.now();
          var blocker = Browser.mainLoop.queue.shift();
          blocker.func(blocker.arg);
          if (Browser.mainLoop.remainingBlockers) {
            var remaining = Browser.mainLoop.remainingBlockers;
            var next =
              remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining);
            if (blocker.counted) {
              Browser.mainLoop.remainingBlockers = next;
            } else {
              next = next + 0.5;
              Browser.mainLoop.remainingBlockers = (8 * remaining + next) / 9;
            }
          }
          out(
            'main loop blocker "' +
              blocker.name +
              '" took ' +
              (Date.now() - start) +
              ' ms'
          );
          Browser.mainLoop.updateStatus();
          if (!checkIsRunning()) return;
          setTimeout(Browser.mainLoop.runner, 0);
          return;
        }
        if (!checkIsRunning()) return;
        Browser.mainLoop.currentFrameNumber =
          (Browser.mainLoop.currentFrameNumber + 1) | 0;
        if (
          Browser.mainLoop.timingMode == 1 &&
          Browser.mainLoop.timingValue > 1 &&
          Browser.mainLoop.currentFrameNumber % Browser.mainLoop.timingValue !=
            0
        ) {
          Browser.mainLoop.scheduler();
          return;
        } else if (Browser.mainLoop.timingMode == 0) {
          Browser.mainLoop.tickStartTime = _emscripten_get_now();
        }
        Browser.mainLoop.runIter(browserIterationFunc);
        if (!checkIsRunning()) return;
        if (typeof SDL === 'object' && SDL.audio && SDL.audio.queueNewAudioData)
          SDL.audio.queueNewAudioData();
        Browser.mainLoop.scheduler();
      };
      if (!noSetTiming) {
        if (fps && fps > 0) _emscripten_set_main_loop_timing(0, 1e3 / fps);
        else _emscripten_set_main_loop_timing(1, 1);
        Browser.mainLoop.scheduler();
      }
      if (simulateInfiniteLoop) {
        throw 'unwind';
      }
    }
    function callUserCallback(func, synchronous) {
      if (ABORT) {
        return;
      }
      if (synchronous) {
        func();
        return;
      }
      try {
        func();
        if (ENVIRONMENT_IS_PTHREAD) maybeExit();
      } catch (e) {
        handleException(e);
      }
    }
    function runtimeKeepalivePop() {
      runtimeKeepaliveCounter -= 1;
    }
    function safeSetTimeout(func, timeout) {
      runtimeKeepalivePush();
      return setTimeout(function () {
        runtimeKeepalivePop();
        callUserCallback(func);
      }, timeout);
    }
    var Browser = {
      mainLoop: {
        running: false,
        scheduler: null,
        method: '',
        currentlyRunningMainloop: 0,
        func: null,
        arg: 0,
        timingMode: 0,
        timingValue: 0,
        currentFrameNumber: 0,
        queue: [],
        pause: function () {
          Browser.mainLoop.scheduler = null;
          Browser.mainLoop.currentlyRunningMainloop++;
        },
        resume: function () {
          Browser.mainLoop.currentlyRunningMainloop++;
          var timingMode = Browser.mainLoop.timingMode;
          var timingValue = Browser.mainLoop.timingValue;
          var func = Browser.mainLoop.func;
          Browser.mainLoop.func = null;
          setMainLoop(func, 0, false, Browser.mainLoop.arg, true);
          _emscripten_set_main_loop_timing(timingMode, timingValue);
          Browser.mainLoop.scheduler();
        },
        updateStatus: function () {
          if (Module['setStatus']) {
            var message = Module['statusMessage'] || 'Please wait...';
            var remaining = Browser.mainLoop.remainingBlockers;
            var expected = Browser.mainLoop.expectedBlockers;
            if (remaining) {
              if (remaining < expected) {
                Module['setStatus'](
                  message + ' (' + (expected - remaining) + '/' + expected + ')'
                );
              } else {
                Module['setStatus'](message);
              }
            } else {
              Module['setStatus']('');
            }
          }
        },
        runIter: function (func) {
          if (ABORT) return;
          if (Module['preMainLoop']) {
            var preRet = Module['preMainLoop']();
            if (preRet === false) {
              return;
            }
          }
          callUserCallback(func);
          if (Module['postMainLoop']) Module['postMainLoop']();
        }
      },
      isFullscreen: false,
      pointerLock: false,
      moduleContextCreatedCallbacks: [],
      workers: [],
      init: function () {
        if (!Module['preloadPlugins']) Module['preloadPlugins'] = [];
        if (Browser.initted) return;
        Browser.initted = true;
        try {
          new Blob();
          Browser.hasBlobConstructor = true;
        } catch (e) {
          Browser.hasBlobConstructor = false;
          out(
            'warning: no blob constructor, cannot create blobs with mimetypes'
          );
        }
        Browser.BlobBuilder =
          typeof MozBlobBuilder != 'undefined'
            ? MozBlobBuilder
            : typeof WebKitBlobBuilder != 'undefined'
            ? WebKitBlobBuilder
            : !Browser.hasBlobConstructor
            ? out('warning: no BlobBuilder')
            : null;
        Browser.URLObject =
          typeof window != 'undefined'
            ? window.URL
              ? window.URL
              : window.webkitURL
            : undefined;
        if (
          !Module.noImageDecoding &&
          typeof Browser.URLObject === 'undefined'
        ) {
          out(
            'warning: Browser does not support creating object URLs. Built-in browser image decoding will not be available.'
          );
          Module.noImageDecoding = true;
        }
        var imagePlugin = {};
        imagePlugin['canHandle'] = function imagePlugin_canHandle(name) {
          return !Module.noImageDecoding && /\.(jpg|jpeg|png|bmp)$/i.test(name);
        };
        imagePlugin['handle'] = function imagePlugin_handle(
          byteArray,
          name,
          onload,
          onerror
        ) {
          var b = null;
          if (Browser.hasBlobConstructor) {
            try {
              b = new Blob([byteArray], { type: Browser.getMimetype(name) });
              if (b.size !== byteArray.length) {
                b = new Blob([new Uint8Array(byteArray).buffer], {
                  type: Browser.getMimetype(name)
                });
              }
            } catch (e) {
              warnOnce(
                'Blob constructor present but fails: ' +
                  e +
                  '; falling back to blob builder'
              );
            }
          }
          if (!b) {
            var bb = new Browser.BlobBuilder();
            bb.append(new Uint8Array(byteArray).buffer);
            b = bb.getBlob();
          }
          var url = Browser.URLObject.createObjectURL(b);
          var img = new Image();
          img.onload = function img_onload() {
            assert(img.complete, 'Image ' + name + ' could not be decoded');
            var canvas = document.createElement('canvas');
            canvas.width = img.width;
            canvas.height = img.height;
            var ctx = canvas.getContext('2d');
            ctx.drawImage(img, 0, 0);
            Module['preloadedImages'][name] = canvas;
            Browser.URLObject.revokeObjectURL(url);
            if (onload) onload(byteArray);
          };
          img.onerror = function img_onerror(event) {
            out('Image ' + url + ' could not be decoded');
            if (onerror) onerror();
          };
          img.src = url;
        };
        Module['preloadPlugins'].push(imagePlugin);
        var audioPlugin = {};
        audioPlugin['canHandle'] = function audioPlugin_canHandle(name) {
          return (
            !Module.noAudioDecoding &&
            name.substr(-4) in { '.ogg': 1, '.wav': 1, '.mp3': 1 }
          );
        };
        audioPlugin['handle'] = function audioPlugin_handle(
          byteArray,
          name,
          onload,
          onerror
        ) {
          var done = false;
          function finish(audio) {
            if (done) return;
            done = true;
            Module['preloadedAudios'][name] = audio;
            if (onload) onload(byteArray);
          }
          function fail() {
            if (done) return;
            done = true;
            Module['preloadedAudios'][name] = new Audio();
            if (onerror) onerror();
          }
          if (Browser.hasBlobConstructor) {
            try {
              var b = new Blob([byteArray], {
                type: Browser.getMimetype(name)
              });
            } catch (e) {
              return fail();
            }
            var url = Browser.URLObject.createObjectURL(b);
            var audio = new Audio();
            audio.addEventListener(
              'canplaythrough',
              function () {
                finish(audio);
              },
              false
            );
            audio.onerror = function audio_onerror(event) {
              if (done) return;
              out(
                'warning: browser could not fully decode audio ' +
                  name +
                  ', trying slower base64 approach'
              );
              function encode64(data) {
                var BASE =
                  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
                var PAD = '=';
                var ret = '';
                var leftchar = 0;
                var leftbits = 0;
                for (var i = 0; i < data.length; i++) {
                  leftchar = (leftchar << 8) | data[i];
                  leftbits += 8;
                  while (leftbits >= 6) {
                    var curr = (leftchar >> (leftbits - 6)) & 63;
                    leftbits -= 6;
                    ret += BASE[curr];
                  }
                }
                if (leftbits == 2) {
                  ret += BASE[(leftchar & 3) << 4];
                  ret += PAD + PAD;
                } else if (leftbits == 4) {
                  ret += BASE[(leftchar & 15) << 2];
                  ret += PAD;
                }
                return ret;
              }
              audio.src =
                'data:audio/x-' +
                name.substr(-3) +
                ';base64,' +
                encode64(byteArray);
              finish(audio);
            };
            audio.src = url;
            safeSetTimeout(function () {
              finish(audio);
            }, 1e4);
          } else {
            return fail();
          }
        };
        Module['preloadPlugins'].push(audioPlugin);
        function pointerLockChange() {
          Browser.pointerLock =
            document['pointerLockElement'] === Module['canvas'] ||
            document['mozPointerLockElement'] === Module['canvas'] ||
            document['webkitPointerLockElement'] === Module['canvas'] ||
            document['msPointerLockElement'] === Module['canvas'];
        }
        var canvas = Module['canvas'];
        if (canvas) {
          canvas.requestPointerLock =
            canvas['requestPointerLock'] ||
            canvas['mozRequestPointerLock'] ||
            canvas['webkitRequestPointerLock'] ||
            canvas['msRequestPointerLock'] ||
            function () {};
          canvas.exitPointerLock =
            document['exitPointerLock'] ||
            document['mozExitPointerLock'] ||
            document['webkitExitPointerLock'] ||
            document['msExitPointerLock'] ||
            function () {};
          canvas.exitPointerLock = canvas.exitPointerLock.bind(document);
          document.addEventListener(
            'pointerlockchange',
            pointerLockChange,
            false
          );
          document.addEventListener(
            'mozpointerlockchange',
            pointerLockChange,
            false
          );
          document.addEventListener(
            'webkitpointerlockchange',
            pointerLockChange,
            false
          );
          document.addEventListener(
            'mspointerlockchange',
            pointerLockChange,
            false
          );
          if (Module['elementPointerLock']) {
            canvas.addEventListener(
              'click',
              function (ev) {
                if (
                  !Browser.pointerLock &&
                  Module['canvas'].requestPointerLock
                ) {
                  Module['canvas'].requestPointerLock();
                  ev.preventDefault();
                }
              },
              false
            );
          }
        }
      },
      createContext: function (
        canvas,
        useWebGL,
        setInModule,
        webGLContextAttributes
      ) {
        if (useWebGL && Module.ctx && canvas == Module.canvas)
          return Module.ctx;
        var ctx;
        var contextHandle;
        if (useWebGL) {
          var contextAttributes = {
            antialias: false,
            alpha: false,
            majorVersion: 1
          };
          if (webGLContextAttributes) {
            for (var attribute in webGLContextAttributes) {
              contextAttributes[attribute] = webGLContextAttributes[attribute];
            }
          }
          if (typeof GL !== 'undefined') {
            contextHandle = GL.createContext(canvas, contextAttributes);
            if (contextHandle) {
              ctx = GL.getContext(contextHandle).GLctx;
            }
          }
        } else {
          ctx = canvas.getContext('2d');
        }
        if (!ctx) return null;
        if (setInModule) {
          if (!useWebGL)
            assert(
              typeof GLctx === 'undefined',
              'cannot set in module if GLctx is used, but we are a non-GL context that would replace it'
            );
          Module.ctx = ctx;
          if (useWebGL) GL.makeContextCurrent(contextHandle);
          Module.useWebGL = useWebGL;
          Browser.moduleContextCreatedCallbacks.forEach(function (callback) {
            callback();
          });
          Browser.init();
        }
        return ctx;
      },
      destroyContext: function (canvas, useWebGL, setInModule) {},
      fullscreenHandlersInstalled: false,
      lockPointer: undefined,
      resizeCanvas: undefined,
      requestFullscreen: function (lockPointer, resizeCanvas) {
        Browser.lockPointer = lockPointer;
        Browser.resizeCanvas = resizeCanvas;
        if (typeof Browser.lockPointer === 'undefined')
          Browser.lockPointer = true;
        if (typeof Browser.resizeCanvas === 'undefined')
          Browser.resizeCanvas = false;
        var canvas = Module['canvas'];
        function fullscreenChange() {
          Browser.isFullscreen = false;
          var canvasContainer = canvas.parentNode;
          if (
            (document['fullscreenElement'] ||
              document['mozFullScreenElement'] ||
              document['msFullscreenElement'] ||
              document['webkitFullscreenElement'] ||
              document['webkitCurrentFullScreenElement']) === canvasContainer
          ) {
            canvas.exitFullscreen = Browser.exitFullscreen;
            if (Browser.lockPointer) canvas.requestPointerLock();
            Browser.isFullscreen = true;
            if (Browser.resizeCanvas) {
              Browser.setFullscreenCanvasSize();
            } else {
              Browser.updateCanvasDimensions(canvas);
            }
          } else {
            canvasContainer.parentNode.insertBefore(canvas, canvasContainer);
            canvasContainer.parentNode.removeChild(canvasContainer);
            if (Browser.resizeCanvas) {
              Browser.setWindowedCanvasSize();
            } else {
              Browser.updateCanvasDimensions(canvas);
            }
          }
          if (Module['onFullScreen'])
            Module['onFullScreen'](Browser.isFullscreen);
          if (Module['onFullscreen'])
            Module['onFullscreen'](Browser.isFullscreen);
        }
        if (!Browser.fullscreenHandlersInstalled) {
          Browser.fullscreenHandlersInstalled = true;
          document.addEventListener(
            'fullscreenchange',
            fullscreenChange,
            false
          );
          document.addEventListener(
            'mozfullscreenchange',
            fullscreenChange,
            false
          );
          document.addEventListener(
            'webkitfullscreenchange',
            fullscreenChange,
            false
          );
          document.addEventListener(
            'MSFullscreenChange',
            fullscreenChange,
            false
          );
        }
        var canvasContainer = document.createElement('div');
        canvas.parentNode.insertBefore(canvasContainer, canvas);
        canvasContainer.appendChild(canvas);
        canvasContainer.requestFullscreen =
          canvasContainer['requestFullscreen'] ||
          canvasContainer['mozRequestFullScreen'] ||
          canvasContainer['msRequestFullscreen'] ||
          (canvasContainer['webkitRequestFullscreen']
            ? function () {
                canvasContainer['webkitRequestFullscreen'](
                  Element['ALLOW_KEYBOARD_INPUT']
                );
              }
            : null) ||
          (canvasContainer['webkitRequestFullScreen']
            ? function () {
                canvasContainer['webkitRequestFullScreen'](
                  Element['ALLOW_KEYBOARD_INPUT']
                );
              }
            : null);
        canvasContainer.requestFullscreen();
      },
      exitFullscreen: function () {
        if (!Browser.isFullscreen) {
          return false;
        }
        var CFS =
          document['exitFullscreen'] ||
          document['cancelFullScreen'] ||
          document['mozCancelFullScreen'] ||
          document['msExitFullscreen'] ||
          document['webkitCancelFullScreen'] ||
          function () {};
        CFS.apply(document, []);
        return true;
      },
      nextRAF: 0,
      fakeRequestAnimationFrame: function (func) {
        var now = Date.now();
        if (Browser.nextRAF === 0) {
          Browser.nextRAF = now + 1e3 / 60;
        } else {
          while (now + 2 >= Browser.nextRAF) {
            Browser.nextRAF += 1e3 / 60;
          }
        }
        var delay = Math.max(Browser.nextRAF - now, 0);
        setTimeout(func, delay);
      },
      requestAnimationFrame: function (func) {
        if (typeof requestAnimationFrame === 'function') {
          requestAnimationFrame(func);
          return;
        }
        var RAF = Browser.fakeRequestAnimationFrame;
        RAF(func);
      },
      safeSetTimeout: function (func) {
        return safeSetTimeout(func);
      },
      safeRequestAnimationFrame: function (func) {
        runtimeKeepalivePush();
        return Browser.requestAnimationFrame(function () {
          runtimeKeepalivePop();
          callUserCallback(func);
        });
      },
      getMimetype: function (name) {
        return {
          jpg: 'image/jpeg',
          jpeg: 'image/jpeg',
          png: 'image/png',
          bmp: 'image/bmp',
          ogg: 'audio/ogg',
          wav: 'audio/wav',
          mp3: 'audio/mpeg'
        }[name.substr(name.lastIndexOf('.') + 1)];
      },
      getUserMedia: function (func) {
        if (!window.getUserMedia) {
          window.getUserMedia =
            navigator['getUserMedia'] || navigator['mozGetUserMedia'];
        }
        window.getUserMedia(func);
      },
      getMovementX: function (event) {
        return (
          event['movementX'] ||
          event['mozMovementX'] ||
          event['webkitMovementX'] ||
          0
        );
      },
      getMovementY: function (event) {
        return (
          event['movementY'] ||
          event['mozMovementY'] ||
          event['webkitMovementY'] ||
          0
        );
      },
      getMouseWheelDelta: function (event) {
        var delta = 0;
        switch (event.type) {
          case 'DOMMouseScroll':
            delta = event.detail / 3;
            break;
          case 'mousewheel':
            delta = event.wheelDelta / 120;
            break;
          case 'wheel':
            delta = event.deltaY;
            switch (event.deltaMode) {
              case 0:
                delta /= 100;
                break;
              case 1:
                delta /= 3;
                break;
              case 2:
                delta *= 80;
                break;
              default:
                throw 'unrecognized mouse wheel delta mode: ' + event.deltaMode;
            }
            break;
          default:
            throw 'unrecognized mouse wheel event: ' + event.type;
        }
        return delta;
      },
      mouseX: 0,
      mouseY: 0,
      mouseMovementX: 0,
      mouseMovementY: 0,
      touches: {},
      lastTouches: {},
      calculateMouseEvent: function (event) {
        if (Browser.pointerLock) {
          if (event.type != 'mousemove' && 'mozMovementX' in event) {
            Browser.mouseMovementX = Browser.mouseMovementY = 0;
          } else {
            Browser.mouseMovementX = Browser.getMovementX(event);
            Browser.mouseMovementY = Browser.getMovementY(event);
          }
          if (typeof SDL != 'undefined') {
            Browser.mouseX = SDL.mouseX + Browser.mouseMovementX;
            Browser.mouseY = SDL.mouseY + Browser.mouseMovementY;
          } else {
            Browser.mouseX += Browser.mouseMovementX;
            Browser.mouseY += Browser.mouseMovementY;
          }
        } else {
          var rect = Module['canvas'].getBoundingClientRect();
          var cw = Module['canvas'].width;
          var ch = Module['canvas'].height;
          var scrollX =
            typeof window.scrollX !== 'undefined'
              ? window.scrollX
              : window.pageXOffset;
          var scrollY =
            typeof window.scrollY !== 'undefined'
              ? window.scrollY
              : window.pageYOffset;
          if (
            event.type === 'touchstart' ||
            event.type === 'touchend' ||
            event.type === 'touchmove'
          ) {
            var touch = event.touch;
            if (touch === undefined) {
              return;
            }
            var adjustedX = touch.pageX - (scrollX + rect.left);
            var adjustedY = touch.pageY - (scrollY + rect.top);
            adjustedX = adjustedX * (cw / rect.width);
            adjustedY = adjustedY * (ch / rect.height);
            var coords = { x: adjustedX, y: adjustedY };
            if (event.type === 'touchstart') {
              Browser.lastTouches[touch.identifier] = coords;
              Browser.touches[touch.identifier] = coords;
            } else if (
              event.type === 'touchend' ||
              event.type === 'touchmove'
            ) {
              var last = Browser.touches[touch.identifier];
              if (!last) last = coords;
              Browser.lastTouches[touch.identifier] = last;
              Browser.touches[touch.identifier] = coords;
            }
            return;
          }
          var x = event.pageX - (scrollX + rect.left);
          var y = event.pageY - (scrollY + rect.top);
          x = x * (cw / rect.width);
          y = y * (ch / rect.height);
          Browser.mouseMovementX = x - Browser.mouseX;
          Browser.mouseMovementY = y - Browser.mouseY;
          Browser.mouseX = x;
          Browser.mouseY = y;
        }
      },
      resizeListeners: [],
      updateResizeListeners: function () {
        var canvas = Module['canvas'];
        Browser.resizeListeners.forEach(function (listener) {
          listener(canvas.width, canvas.height);
        });
      },
      setCanvasSize: function (width, height, noUpdates) {
        var canvas = Module['canvas'];
        Browser.updateCanvasDimensions(canvas, width, height);
        if (!noUpdates) Browser.updateResizeListeners();
      },
      windowedWidth: 0,
      windowedHeight: 0,
      setFullscreenCanvasSize: function () {
        if (typeof SDL != 'undefined') {
          var flags = HEAPU32[SDL.screen >> 2];
          flags = flags | 8388608;
          HEAP32[SDL.screen >> 2] = flags;
        }
        Browser.updateCanvasDimensions(Module['canvas']);
        Browser.updateResizeListeners();
      },
      setWindowedCanvasSize: function () {
        if (typeof SDL != 'undefined') {
          var flags = HEAPU32[SDL.screen >> 2];
          flags = flags & ~8388608;
          HEAP32[SDL.screen >> 2] = flags;
        }
        Browser.updateCanvasDimensions(Module['canvas']);
        Browser.updateResizeListeners();
      },
      updateCanvasDimensions: function (canvas, wNative, hNative) {
        if (wNative && hNative) {
          canvas.widthNative = wNative;
          canvas.heightNative = hNative;
        } else {
          wNative = canvas.widthNative;
          hNative = canvas.heightNative;
        }
        var w = wNative;
        var h = hNative;
        if (Module['forcedAspectRatio'] && Module['forcedAspectRatio'] > 0) {
          if (w / h < Module['forcedAspectRatio']) {
            w = Math.round(h * Module['forcedAspectRatio']);
          } else {
            h = Math.round(w / Module['forcedAspectRatio']);
          }
        }
        if (
          (document['fullscreenElement'] ||
            document['mozFullScreenElement'] ||
            document['msFullscreenElement'] ||
            document['webkitFullscreenElement'] ||
            document['webkitCurrentFullScreenElement']) === canvas.parentNode &&
          typeof screen != 'undefined'
        ) {
          var factor = Math.min(screen.width / w, screen.height / h);
          w = Math.round(w * factor);
          h = Math.round(h * factor);
        }
        if (Browser.resizeCanvas) {
          if (canvas.width != w) canvas.width = w;
          if (canvas.height != h) canvas.height = h;
          if (typeof canvas.style != 'undefined') {
            canvas.style.removeProperty('width');
            canvas.style.removeProperty('height');
          }
        } else {
          if (canvas.width != wNative) canvas.width = wNative;
          if (canvas.height != hNative) canvas.height = hNative;
          if (typeof canvas.style != 'undefined') {
            if (w != wNative || h != hNative) {
              canvas.style.setProperty('width', w + 'px', 'important');
              canvas.style.setProperty('height', h + 'px', 'important');
            } else {
              canvas.style.removeProperty('width');
              canvas.style.removeProperty('height');
            }
          }
        }
      }
    };
    var AL = {
      QUEUE_INTERVAL: 25,
      QUEUE_LOOKAHEAD: 0.1,
      DEVICE_NAME: 'Emscripten OpenAL',
      CAPTURE_DEVICE_NAME: 'Emscripten OpenAL capture',
      ALC_EXTENSIONS: { ALC_SOFT_pause_device: true, ALC_SOFT_HRTF: true },
      AL_EXTENSIONS: {
        AL_EXT_float32: true,
        AL_SOFT_loop_points: true,
        AL_SOFT_source_length: true,
        AL_EXT_source_distance_model: true,
        AL_SOFT_source_spatialize: true
      },
      _alcErr: 0,
      alcErr: 0,
      deviceRefCounts: {},
      alcStringCache: {},
      paused: false,
      stringCache: {},
      contexts: {},
      currentCtx: null,
      buffers: {
        0: {
          id: 0,
          refCount: 0,
          audioBuf: null,
          frequency: 0,
          bytesPerSample: 2,
          channels: 1,
          length: 0
        }
      },
      paramArray: [],
      _nextId: 1,
      newId: function () {
        return AL.freeIds.length > 0 ? AL.freeIds.pop() : AL._nextId++;
      },
      freeIds: [],
      scheduleContextAudio: function (ctx) {
        if (
          Browser.mainLoop.timingMode === 1 &&
          document['visibilityState'] != 'visible'
        ) {
          return;
        }
        for (var i in ctx.sources) {
          AL.scheduleSourceAudio(ctx.sources[i]);
        }
      },
      scheduleSourceAudio: function (src, lookahead) {
        if (
          Browser.mainLoop.timingMode === 1 &&
          document['visibilityState'] != 'visible'
        ) {
          return;
        }
        if (src.state !== 4114) {
          return;
        }
        var currentTime = AL.updateSourceTime(src);
        var startTime = src.bufStartTime;
        var startOffset = src.bufOffset;
        var bufCursor = src.bufsProcessed;
        for (var i = 0; i < src.audioQueue.length; i++) {
          var audioSrc = src.audioQueue[i];
          startTime = audioSrc._startTime + audioSrc._duration;
          startOffset = 0;
          bufCursor += audioSrc._skipCount + 1;
        }
        if (!lookahead) {
          lookahead = AL.QUEUE_LOOKAHEAD;
        }
        var lookaheadTime = currentTime + lookahead;
        var skipCount = 0;
        while (startTime < lookaheadTime) {
          if (bufCursor >= src.bufQueue.length) {
            if (src.looping) {
              bufCursor %= src.bufQueue.length;
            } else {
              break;
            }
          }
          var buf = src.bufQueue[bufCursor % src.bufQueue.length];
          if (buf.length === 0) {
            skipCount++;
            if (skipCount === src.bufQueue.length) {
              break;
            }
          } else {
            var audioSrc = src.context.audioCtx.createBufferSource();
            audioSrc.buffer = buf.audioBuf;
            audioSrc.playbackRate.value = src.playbackRate;
            if (buf.audioBuf._loopStart || buf.audioBuf._loopEnd) {
              audioSrc.loopStart = buf.audioBuf._loopStart;
              audioSrc.loopEnd = buf.audioBuf._loopEnd;
            }
            var duration = 0;
            if (src.type === 4136 && src.looping) {
              duration = Number.POSITIVE_INFINITY;
              audioSrc.loop = true;
              if (buf.audioBuf._loopStart) {
                audioSrc.loopStart = buf.audioBuf._loopStart;
              }
              if (buf.audioBuf._loopEnd) {
                audioSrc.loopEnd = buf.audioBuf._loopEnd;
              }
            } else {
              duration =
                (buf.audioBuf.duration - startOffset) / src.playbackRate;
            }
            audioSrc._startOffset = startOffset;
            audioSrc._duration = duration;
            audioSrc._skipCount = skipCount;
            skipCount = 0;
            audioSrc.connect(src.gain);
            if (typeof audioSrc.start !== 'undefined') {
              startTime = Math.max(startTime, src.context.audioCtx.currentTime);
              audioSrc.start(startTime, startOffset);
            } else if (typeof audioSrc.noteOn !== 'undefined') {
              startTime = Math.max(startTime, src.context.audioCtx.currentTime);
              audioSrc.noteOn(startTime);
            }
            audioSrc._startTime = startTime;
            src.audioQueue.push(audioSrc);
            startTime += duration;
          }
          startOffset = 0;
          bufCursor++;
        }
      },
      updateSourceTime: function (src) {
        var currentTime = src.context.audioCtx.currentTime;
        if (src.state !== 4114) {
          return currentTime;
        }
        if (!isFinite(src.bufStartTime)) {
          src.bufStartTime = currentTime - src.bufOffset / src.playbackRate;
          src.bufOffset = 0;
        }
        var nextStartTime = 0;
        while (src.audioQueue.length) {
          var audioSrc = src.audioQueue[0];
          src.bufsProcessed += audioSrc._skipCount;
          nextStartTime = audioSrc._startTime + audioSrc._duration;
          if (currentTime < nextStartTime) {
            break;
          }
          src.audioQueue.shift();
          src.bufStartTime = nextStartTime;
          src.bufOffset = 0;
          src.bufsProcessed++;
        }
        if (src.bufsProcessed >= src.bufQueue.length && !src.looping) {
          AL.setSourceState(src, 4116);
        } else if (src.type === 4136 && src.looping) {
          var buf = src.bufQueue[0];
          if (buf.length === 0) {
            src.bufOffset = 0;
          } else {
            var delta = (currentTime - src.bufStartTime) * src.playbackRate;
            var loopStart = buf.audioBuf._loopStart || 0;
            var loopEnd = buf.audioBuf._loopEnd || buf.audioBuf.duration;
            if (loopEnd <= loopStart) {
              loopEnd = buf.audioBuf.duration;
            }
            if (delta < loopEnd) {
              src.bufOffset = delta;
            } else {
              src.bufOffset =
                loopStart + ((delta - loopStart) % (loopEnd - loopStart));
            }
          }
        } else if (src.audioQueue[0]) {
          src.bufOffset =
            (currentTime - src.audioQueue[0]._startTime) * src.playbackRate;
        } else {
          if (src.type !== 4136 && src.looping) {
            var srcDuration = AL.sourceDuration(src) / src.playbackRate;
            if (srcDuration > 0) {
              src.bufStartTime +=
                Math.floor((currentTime - src.bufStartTime) / srcDuration) *
                srcDuration;
            }
          }
          for (var i = 0; i < src.bufQueue.length; i++) {
            if (src.bufsProcessed >= src.bufQueue.length) {
              if (src.looping) {
                src.bufsProcessed %= src.bufQueue.length;
              } else {
                AL.setSourceState(src, 4116);
                break;
              }
            }
            var buf = src.bufQueue[src.bufsProcessed];
            if (buf.length > 0) {
              nextStartTime =
                src.bufStartTime + buf.audioBuf.duration / src.playbackRate;
              if (currentTime < nextStartTime) {
                src.bufOffset =
                  (currentTime - src.bufStartTime) * src.playbackRate;
                break;
              }
              src.bufStartTime = nextStartTime;
            }
            src.bufOffset = 0;
            src.bufsProcessed++;
          }
        }
        return currentTime;
      },
      cancelPendingSourceAudio: function (src) {
        AL.updateSourceTime(src);
        for (var i = 1; i < src.audioQueue.length; i++) {
          var audioSrc = src.audioQueue[i];
          audioSrc.stop();
        }
        if (src.audioQueue.length > 1) {
          src.audioQueue.length = 1;
        }
      },
      stopSourceAudio: function (src) {
        for (var i = 0; i < src.audioQueue.length; i++) {
          src.audioQueue[i].stop();
        }
        src.audioQueue.length = 0;
      },
      setSourceState: function (src, state) {
        if (state === 4114) {
          if (src.state === 4114 || src.state == 4116) {
            src.bufsProcessed = 0;
            src.bufOffset = 0;
          } else {
          }
          AL.stopSourceAudio(src);
          src.state = 4114;
          src.bufStartTime = Number.NEGATIVE_INFINITY;
          AL.scheduleSourceAudio(src);
        } else if (state === 4115) {
          if (src.state === 4114) {
            AL.updateSourceTime(src);
            AL.stopSourceAudio(src);
            src.state = 4115;
          }
        } else if (state === 4116) {
          if (src.state !== 4113) {
            src.state = 4116;
            src.bufsProcessed = src.bufQueue.length;
            src.bufStartTime = Number.NEGATIVE_INFINITY;
            src.bufOffset = 0;
            AL.stopSourceAudio(src);
          }
        } else if (state === 4113) {
          if (src.state !== 4113) {
            src.state = 4113;
            src.bufsProcessed = 0;
            src.bufStartTime = Number.NEGATIVE_INFINITY;
            src.bufOffset = 0;
            AL.stopSourceAudio(src);
          }
        }
      },
      initSourcePanner: function (src) {
        if (src.type === 4144) {
          return;
        }
        var templateBuf = AL.buffers[0];
        for (var i = 0; i < src.bufQueue.length; i++) {
          if (src.bufQueue[i].id !== 0) {
            templateBuf = src.bufQueue[i];
            break;
          }
        }
        if (
          src.spatialize === 1 ||
          (src.spatialize === 2 && templateBuf.channels === 1)
        ) {
          if (src.panner) {
            return;
          }
          src.panner = src.context.audioCtx.createPanner();
          AL.updateSourceGlobal(src);
          AL.updateSourceSpace(src);
          src.panner.connect(src.context.gain);
          src.gain.disconnect();
          src.gain.connect(src.panner);
        } else {
          if (!src.panner) {
            return;
          }
          src.panner.disconnect();
          src.gain.disconnect();
          src.gain.connect(src.context.gain);
          src.panner = null;
        }
      },
      updateContextGlobal: function (ctx) {
        for (var i in ctx.sources) {
          AL.updateSourceGlobal(ctx.sources[i]);
        }
      },
      updateSourceGlobal: function (src) {
        var panner = src.panner;
        if (!panner) {
          return;
        }
        panner.refDistance = src.refDistance;
        panner.maxDistance = src.maxDistance;
        panner.rolloffFactor = src.rolloffFactor;
        panner.panningModel = src.context.hrtf ? 'HRTF' : 'equalpower';
        var distanceModel = src.context.sourceDistanceModel
          ? src.distanceModel
          : src.context.distanceModel;
        switch (distanceModel) {
          case 0:
            panner.distanceModel = 'inverse';
            panner.refDistance = 3.40282e38;
            break;
          case 53249:
          case 53250:
            panner.distanceModel = 'inverse';
            break;
          case 53251:
          case 53252:
            panner.distanceModel = 'linear';
            break;
          case 53253:
          case 53254:
            panner.distanceModel = 'exponential';
            break;
        }
      },
      updateListenerSpace: function (ctx) {
        var listener = ctx.audioCtx.listener;
        if (listener.positionX) {
          listener.positionX.value = ctx.listener.position[0];
          listener.positionY.value = ctx.listener.position[1];
          listener.positionZ.value = ctx.listener.position[2];
        } else {
          listener.setPosition(
            ctx.listener.position[0],
            ctx.listener.position[1],
            ctx.listener.position[2]
          );
        }
        if (listener.forwardX) {
          listener.forwardX.value = ctx.listener.direction[0];
          listener.forwardY.value = ctx.listener.direction[1];
          listener.forwardZ.value = ctx.listener.direction[2];
          listener.upX.value = ctx.listener.up[0];
          listener.upY.value = ctx.listener.up[1];
          listener.upZ.value = ctx.listener.up[2];
        } else {
          listener.setOrientation(
            ctx.listener.direction[0],
            ctx.listener.direction[1],
            ctx.listener.direction[2],
            ctx.listener.up[0],
            ctx.listener.up[1],
            ctx.listener.up[2]
          );
        }
        for (var i in ctx.sources) {
          AL.updateSourceSpace(ctx.sources[i]);
        }
      },
      updateSourceSpace: function (src) {
        if (!src.panner) {
          return;
        }
        var panner = src.panner;
        var posX = src.position[0];
        var posY = src.position[1];
        var posZ = src.position[2];
        var dirX = src.direction[0];
        var dirY = src.direction[1];
        var dirZ = src.direction[2];
        var listener = src.context.listener;
        var lPosX = listener.position[0];
        var lPosY = listener.position[1];
        var lPosZ = listener.position[2];
        if (src.relative) {
          var lBackX = -listener.direction[0];
          var lBackY = -listener.direction[1];
          var lBackZ = -listener.direction[2];
          var lUpX = listener.up[0];
          var lUpY = listener.up[1];
          var lUpZ = listener.up[2];
          var inverseMagnitude = function (x, y, z) {
            var length = Math.sqrt(x * x + y * y + z * z);
            if (length < Number.EPSILON) {
              return 0;
            }
            return 1 / length;
          };
          var invMag = inverseMagnitude(lBackX, lBackY, lBackZ);
          lBackX *= invMag;
          lBackY *= invMag;
          lBackZ *= invMag;
          invMag = inverseMagnitude(lUpX, lUpY, lUpZ);
          lUpX *= invMag;
          lUpY *= invMag;
          lUpZ *= invMag;
          var lRightX = lUpY * lBackZ - lUpZ * lBackY;
          var lRightY = lUpZ * lBackX - lUpX * lBackZ;
          var lRightZ = lUpX * lBackY - lUpY * lBackX;
          invMag = inverseMagnitude(lRightX, lRightY, lRightZ);
          lRightX *= invMag;
          lRightY *= invMag;
          lRightZ *= invMag;
          lUpX = lBackY * lRightZ - lBackZ * lRightY;
          lUpY = lBackZ * lRightX - lBackX * lRightZ;
          lUpZ = lBackX * lRightY - lBackY * lRightX;
          var oldX = dirX;
          var oldY = dirY;
          var oldZ = dirZ;
          dirX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
          dirY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
          dirZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;
          oldX = posX;
          oldY = posY;
          oldZ = posZ;
          posX = oldX * lRightX + oldY * lUpX + oldZ * lBackX;
          posY = oldX * lRightY + oldY * lUpY + oldZ * lBackY;
          posZ = oldX * lRightZ + oldY * lUpZ + oldZ * lBackZ;
          posX += lPosX;
          posY += lPosY;
          posZ += lPosZ;
        }
        if (panner.positionX) {
          panner.positionX.value = posX;
          panner.positionY.value = posY;
          panner.positionZ.value = posZ;
        } else {
          panner.setPosition(posX, posY, posZ);
        }
        if (panner.orientationX) {
          panner.orientationX.value = dirX;
          panner.orientationY.value = dirY;
          panner.orientationZ.value = dirZ;
        } else {
          panner.setOrientation(dirX, dirY, dirZ);
        }
        var oldShift = src.dopplerShift;
        var velX = src.velocity[0];
        var velY = src.velocity[1];
        var velZ = src.velocity[2];
        var lVelX = listener.velocity[0];
        var lVelY = listener.velocity[1];
        var lVelZ = listener.velocity[2];
        if (
          (posX === lPosX && posY === lPosY && posZ === lPosZ) ||
          (velX === lVelX && velY === lVelY && velZ === lVelZ)
        ) {
          src.dopplerShift = 1;
        } else {
          var speedOfSound = src.context.speedOfSound;
          var dopplerFactor = src.context.dopplerFactor;
          var slX = lPosX - posX;
          var slY = lPosY - posY;
          var slZ = lPosZ - posZ;
          var magSl = Math.sqrt(slX * slX + slY * slY + slZ * slZ);
          var vls = (slX * lVelX + slY * lVelY + slZ * lVelZ) / magSl;
          var vss = (slX * velX + slY * velY + slZ * velZ) / magSl;
          vls = Math.min(vls, speedOfSound / dopplerFactor);
          vss = Math.min(vss, speedOfSound / dopplerFactor);
          src.dopplerShift =
            (speedOfSound - dopplerFactor * vls) /
            (speedOfSound - dopplerFactor * vss);
        }
        if (src.dopplerShift !== oldShift) {
          AL.updateSourceRate(src);
        }
      },
      updateSourceRate: function (src) {
        if (src.state === 4114) {
          AL.cancelPendingSourceAudio(src);
          var audioSrc = src.audioQueue[0];
          if (!audioSrc) {
            return;
          }
          var duration;
          if (src.type === 4136 && src.looping) {
            duration = Number.POSITIVE_INFINITY;
          } else {
            duration =
              (audioSrc.buffer.duration - audioSrc._startOffset) /
              src.playbackRate;
          }
          audioSrc._duration = duration;
          audioSrc.playbackRate.value = src.playbackRate;
          AL.scheduleSourceAudio(src);
        }
      },
      sourceDuration: function (src) {
        var length = 0;
        for (var i = 0; i < src.bufQueue.length; i++) {
          var audioBuf = src.bufQueue[i].audioBuf;
          length += audioBuf ? audioBuf.duration : 0;
        }
        return length;
      },
      sourceTell: function (src) {
        AL.updateSourceTime(src);
        var offset = 0;
        for (var i = 0; i < src.bufsProcessed; i++) {
          offset += src.bufQueue[i].audioBuf.duration;
        }
        offset += src.bufOffset;
        return offset;
      },
      sourceSeek: function (src, offset) {
        var playing = src.state == 4114;
        if (playing) {
          AL.setSourceState(src, 4113);
        }
        if (src.bufQueue[src.bufsProcessed].audioBuf !== null) {
          src.bufsProcessed = 0;
          while (offset > src.bufQueue[src.bufsProcessed].audioBuf.duration) {
            offset -= src.bufQueue[src.bufsProcessed].audiobuf.duration;
            src.bufsProcessed++;
          }
          src.bufOffset = offset;
        }
        if (playing) {
          AL.setSourceState(src, 4114);
        }
      },
      getGlobalParam: function (funcname, param) {
        if (!AL.currentCtx) {
          return null;
        }
        switch (param) {
          case 49152:
            return AL.currentCtx.dopplerFactor;
          case 49155:
            return AL.currentCtx.speedOfSound;
          case 53248:
            return AL.currentCtx.distanceModel;
          default:
            AL.currentCtx.err = 40962;
            return null;
        }
      },
      setGlobalParam: function (funcname, param, value) {
        if (!AL.currentCtx) {
          return;
        }
        switch (param) {
          case 49152:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.currentCtx.dopplerFactor = value;
            AL.updateListenerSpace(AL.currentCtx);
            break;
          case 49155:
            if (!Number.isFinite(value) || value <= 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.currentCtx.speedOfSound = value;
            AL.updateListenerSpace(AL.currentCtx);
            break;
          case 53248:
            switch (value) {
              case 0:
              case 53249:
              case 53250:
              case 53251:
              case 53252:
              case 53253:
              case 53254:
                AL.currentCtx.distanceModel = value;
                AL.updateContextGlobal(AL.currentCtx);
                break;
              default:
                AL.currentCtx.err = 40963;
                return;
            }
            break;
          default:
            AL.currentCtx.err = 40962;
            return;
        }
      },
      getListenerParam: function (funcname, param) {
        if (!AL.currentCtx) {
          return null;
        }
        switch (param) {
          case 4100:
            return AL.currentCtx.listener.position;
          case 4102:
            return AL.currentCtx.listener.velocity;
          case 4111:
            return AL.currentCtx.listener.direction.concat(
              AL.currentCtx.listener.up
            );
          case 4106:
            return AL.currentCtx.gain.gain.value;
          default:
            AL.currentCtx.err = 40962;
            return null;
        }
      },
      setListenerParam: function (funcname, param, value) {
        if (!AL.currentCtx) {
          return;
        }
        if (value === null) {
          AL.currentCtx.err = 40962;
          return;
        }
        var listener = AL.currentCtx.listener;
        switch (param) {
          case 4100:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            listener.position[0] = value[0];
            listener.position[1] = value[1];
            listener.position[2] = value[2];
            AL.updateListenerSpace(AL.currentCtx);
            break;
          case 4102:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            listener.velocity[0] = value[0];
            listener.velocity[1] = value[1];
            listener.velocity[2] = value[2];
            AL.updateListenerSpace(AL.currentCtx);
            break;
          case 4106:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.currentCtx.gain.gain.value = value;
            break;
          case 4111:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2]) ||
              !Number.isFinite(value[3]) ||
              !Number.isFinite(value[4]) ||
              !Number.isFinite(value[5])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            listener.direction[0] = value[0];
            listener.direction[1] = value[1];
            listener.direction[2] = value[2];
            listener.up[0] = value[3];
            listener.up[1] = value[4];
            listener.up[2] = value[5];
            AL.updateListenerSpace(AL.currentCtx);
            break;
          default:
            AL.currentCtx.err = 40962;
            return;
        }
      },
      getBufferParam: function (funcname, bufferId, param) {
        if (!AL.currentCtx) {
          return;
        }
        var buf = AL.buffers[bufferId];
        if (!buf || bufferId === 0) {
          AL.currentCtx.err = 40961;
          return;
        }
        switch (param) {
          case 8193:
            return buf.frequency;
          case 8194:
            return buf.bytesPerSample * 8;
          case 8195:
            return buf.channels;
          case 8196:
            return buf.length * buf.bytesPerSample * buf.channels;
          case 8213:
            if (buf.length === 0) {
              return [0, 0];
            } else {
              return [
                (buf.audioBuf._loopStart || 0) * buf.frequency,
                (buf.audioBuf._loopEnd || buf.length) * buf.frequency
              ];
            }
          default:
            AL.currentCtx.err = 40962;
            return null;
        }
      },
      setBufferParam: function (funcname, bufferId, param, value) {
        if (!AL.currentCtx) {
          return;
        }
        var buf = AL.buffers[bufferId];
        if (!buf || bufferId === 0) {
          AL.currentCtx.err = 40961;
          return;
        }
        if (value === null) {
          AL.currentCtx.err = 40962;
          return;
        }
        switch (param) {
          case 8196:
            if (value !== 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            break;
          case 8213:
            if (
              value[0] < 0 ||
              value[0] > buf.length ||
              value[1] < 0 ||
              value[1] > buf.Length ||
              value[0] >= value[1]
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            if (buf.refCount > 0) {
              AL.currentCtx.err = 40964;
              return;
            }
            if (buf.audioBuf) {
              buf.audioBuf._loopStart = value[0] / buf.frequency;
              buf.audioBuf._loopEnd = value[1] / buf.frequency;
            }
            break;
          default:
            AL.currentCtx.err = 40962;
            return;
        }
      },
      getSourceParam: function (funcname, sourceId, param) {
        if (!AL.currentCtx) {
          return null;
        }
        var src = AL.currentCtx.sources[sourceId];
        if (!src) {
          AL.currentCtx.err = 40961;
          return null;
        }
        switch (param) {
          case 514:
            return src.relative;
          case 4097:
            return src.coneInnerAngle;
          case 4098:
            return src.coneOuterAngle;
          case 4099:
            return src.pitch;
          case 4100:
            return src.position;
          case 4101:
            return src.direction;
          case 4102:
            return src.velocity;
          case 4103:
            return src.looping;
          case 4105:
            if (src.type === 4136) {
              return src.bufQueue[0].id;
            } else {
              return 0;
            }
          case 4106:
            return src.gain.gain.value;
          case 4109:
            return src.minGain;
          case 4110:
            return src.maxGain;
          case 4112:
            return src.state;
          case 4117:
            if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
              return 0;
            } else {
              return src.bufQueue.length;
            }
          case 4118:
            if (
              (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) ||
              src.looping
            ) {
              return 0;
            } else {
              return src.bufsProcessed;
            }
          case 4128:
            return src.refDistance;
          case 4129:
            return src.rolloffFactor;
          case 4130:
            return src.coneOuterGain;
          case 4131:
            return src.maxDistance;
          case 4132:
            return AL.sourceTell(src);
          case 4133:
            var offset = AL.sourceTell(src);
            if (offset > 0) {
              offset *= src.bufQueue[0].frequency;
            }
            return offset;
          case 4134:
            var offset = AL.sourceTell(src);
            if (offset > 0) {
              offset *=
                src.bufQueue[0].frequency * src.bufQueue[0].bytesPerSample;
            }
            return offset;
          case 4135:
            return src.type;
          case 4628:
            return src.spatialize;
          case 8201:
            var length = 0;
            var bytesPerFrame = 0;
            for (var i = 0; i < src.bufQueue.length; i++) {
              length += src.bufQueue[i].length;
              if (src.bufQueue[i].id !== 0) {
                bytesPerFrame =
                  src.bufQueue[i].bytesPerSample * src.bufQueue[i].channels;
              }
            }
            return length * bytesPerFrame;
          case 8202:
            var length = 0;
            for (var i = 0; i < src.bufQueue.length; i++) {
              length += src.bufQueue[i].length;
            }
            return length;
          case 8203:
            return AL.sourceDuration(src);
          case 53248:
            return src.distanceModel;
          default:
            AL.currentCtx.err = 40962;
            return null;
        }
      },
      setSourceParam: function (funcname, sourceId, param, value) {
        if (!AL.currentCtx) {
          return;
        }
        var src = AL.currentCtx.sources[sourceId];
        if (!src) {
          AL.currentCtx.err = 40961;
          return;
        }
        if (value === null) {
          AL.currentCtx.err = 40962;
          return;
        }
        switch (param) {
          case 514:
            if (value === 1) {
              src.relative = true;
              AL.updateSourceSpace(src);
            } else if (value === 0) {
              src.relative = false;
              AL.updateSourceSpace(src);
            } else {
              AL.currentCtx.err = 40963;
              return;
            }
            break;
          case 4097:
            if (!Number.isFinite(value)) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.coneInnerAngle = value;
            if (src.panner) {
              src.panner.coneInnerAngle = value % 360;
            }
            break;
          case 4098:
            if (!Number.isFinite(value)) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.coneOuterAngle = value;
            if (src.panner) {
              src.panner.coneOuterAngle = value % 360;
            }
            break;
          case 4099:
            if (!Number.isFinite(value) || value <= 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            if (src.pitch === value) {
              break;
            }
            src.pitch = value;
            AL.updateSourceRate(src);
            break;
          case 4100:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.position[0] = value[0];
            src.position[1] = value[1];
            src.position[2] = value[2];
            AL.updateSourceSpace(src);
            break;
          case 4101:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.direction[0] = value[0];
            src.direction[1] = value[1];
            src.direction[2] = value[2];
            AL.updateSourceSpace(src);
            break;
          case 4102:
            if (
              !Number.isFinite(value[0]) ||
              !Number.isFinite(value[1]) ||
              !Number.isFinite(value[2])
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.velocity[0] = value[0];
            src.velocity[1] = value[1];
            src.velocity[2] = value[2];
            AL.updateSourceSpace(src);
            break;
          case 4103:
            if (value === 1) {
              src.looping = true;
              AL.updateSourceTime(src);
              if (src.type === 4136 && src.audioQueue.length > 0) {
                var audioSrc = src.audioQueue[0];
                audioSrc.loop = true;
                audioSrc._duration = Number.POSITIVE_INFINITY;
              }
            } else if (value === 0) {
              src.looping = false;
              var currentTime = AL.updateSourceTime(src);
              if (src.type === 4136 && src.audioQueue.length > 0) {
                var audioSrc = src.audioQueue[0];
                audioSrc.loop = false;
                audioSrc._duration =
                  src.bufQueue[0].audioBuf.duration / src.playbackRate;
                audioSrc._startTime =
                  currentTime - src.bufOffset / src.playbackRate;
              }
            } else {
              AL.currentCtx.err = 40963;
              return;
            }
            break;
          case 4105:
            if (src.state === 4114 || src.state === 4115) {
              AL.currentCtx.err = 40964;
              return;
            }
            if (value === 0) {
              for (var i in src.bufQueue) {
                src.bufQueue[i].refCount--;
              }
              src.bufQueue.length = 1;
              src.bufQueue[0] = AL.buffers[0];
              src.bufsProcessed = 0;
              src.type = 4144;
            } else {
              var buf = AL.buffers[value];
              if (!buf) {
                AL.currentCtx.err = 40963;
                return;
              }
              for (var i in src.bufQueue) {
                src.bufQueue[i].refCount--;
              }
              src.bufQueue.length = 0;
              buf.refCount++;
              src.bufQueue = [buf];
              src.bufsProcessed = 0;
              src.type = 4136;
            }
            AL.initSourcePanner(src);
            AL.scheduleSourceAudio(src);
            break;
          case 4106:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.gain.gain.value = value;
            break;
          case 4109:
            if (
              !Number.isFinite(value) ||
              value < 0 ||
              value > Math.min(src.maxGain, 1)
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.minGain = value;
            break;
          case 4110:
            if (
              !Number.isFinite(value) ||
              value < Math.max(0, src.minGain) ||
              value > 1
            ) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.maxGain = value;
            break;
          case 4128:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.refDistance = value;
            if (src.panner) {
              src.panner.refDistance = value;
            }
            break;
          case 4129:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.rolloffFactor = value;
            if (src.panner) {
              src.panner.rolloffFactor = value;
            }
            break;
          case 4130:
            if (!Number.isFinite(value) || value < 0 || value > 1) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.coneOuterGain = value;
            if (src.panner) {
              src.panner.coneOuterGain = value;
            }
            break;
          case 4131:
            if (!Number.isFinite(value) || value < 0) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.maxDistance = value;
            if (src.panner) {
              src.panner.maxDistance = value;
            }
            break;
          case 4132:
            if (value < 0 || value > AL.sourceDuration(src)) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.sourceSeek(src, value);
            break;
          case 4133:
            var srcLen = AL.sourceDuration(src);
            if (srcLen > 0) {
              var frequency;
              for (var bufId in src.bufQueue) {
                if (bufId) {
                  frequency = src.bufQueue[bufId].frequency;
                  break;
                }
              }
              value /= frequency;
            }
            if (value < 0 || value > srcLen) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.sourceSeek(src, value);
            break;
          case 4134:
            var srcLen = AL.sourceDuration(src);
            if (srcLen > 0) {
              var bytesPerSec;
              for (var bufId in src.bufQueue) {
                if (bufId) {
                  var buf = src.bufQueue[bufId];
                  bytesPerSec =
                    buf.frequency * buf.bytesPerSample * buf.channels;
                  break;
                }
              }
              value /= bytesPerSec;
            }
            if (value < 0 || value > srcLen) {
              AL.currentCtx.err = 40963;
              return;
            }
            AL.sourceSeek(src, value);
            break;
          case 4628:
            if (value !== 0 && value !== 1 && value !== 2) {
              AL.currentCtx.err = 40963;
              return;
            }
            src.spatialize = value;
            AL.initSourcePanner(src);
            break;
          case 8201:
          case 8202:
          case 8203:
            AL.currentCtx.err = 40964;
            break;
          case 53248:
            switch (value) {
              case 0:
              case 53249:
              case 53250:
              case 53251:
              case 53252:
              case 53253:
              case 53254:
                src.distanceModel = value;
                if (AL.currentCtx.sourceDistanceModel) {
                  AL.updateContextGlobal(AL.currentCtx);
                }
                break;
              default:
                AL.currentCtx.err = 40963;
                return;
            }
            break;
          default:
            AL.currentCtx.err = 40962;
            return;
        }
      },
      captures: {},
      sharedCaptureAudioCtx: null,
      requireValidCaptureDevice: function (deviceId, funcname) {
        if (deviceId === 0) {
          AL.alcErr = 40961;
          return null;
        }
        var c = AL.captures[deviceId];
        if (!c) {
          AL.alcErr = 40961;
          return null;
        }
        var err = c.mediaStreamError;
        if (err) {
          AL.alcErr = 40961;
          return null;
        }
        return c;
      }
    };
    function _alBufferData(bufferId, format, pData, size, freq) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          6,
          1,
          bufferId,
          format,
          pData,
          size,
          freq
        );
      if (!AL.currentCtx) {
        return;
      }
      var buf = AL.buffers[bufferId];
      if (!buf) {
        AL.currentCtx.err = 40963;
        return;
      }
      if (freq <= 0) {
        AL.currentCtx.err = 40963;
        return;
      }
      var audioBuf = null;
      try {
        switch (format) {
          case 4352:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(1, size, freq);
              var channel0 = audioBuf.getChannelData(0);
              for (var i = 0; i < size; ++i) {
                channel0[i] = HEAPU8[pData++] * 0.0078125 - 1;
              }
            }
            buf.bytesPerSample = 1;
            buf.channels = 1;
            buf.length = size;
            break;
          case 4353:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(
                1,
                size >> 1,
                freq
              );
              var channel0 = audioBuf.getChannelData(0);
              pData >>= 1;
              for (var i = 0; i < size >> 1; ++i) {
                channel0[i] = HEAP16[pData++] * 30517578125e-15;
              }
            }
            buf.bytesPerSample = 2;
            buf.channels = 1;
            buf.length = size >> 1;
            break;
          case 4354:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(
                2,
                size >> 1,
                freq
              );
              var channel0 = audioBuf.getChannelData(0);
              var channel1 = audioBuf.getChannelData(1);
              for (var i = 0; i < size >> 1; ++i) {
                channel0[i] = HEAPU8[pData++] * 0.0078125 - 1;
                channel1[i] = HEAPU8[pData++] * 0.0078125 - 1;
              }
            }
            buf.bytesPerSample = 1;
            buf.channels = 2;
            buf.length = size >> 1;
            break;
          case 4355:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(
                2,
                size >> 2,
                freq
              );
              var channel0 = audioBuf.getChannelData(0);
              var channel1 = audioBuf.getChannelData(1);
              pData >>= 1;
              for (var i = 0; i < size >> 2; ++i) {
                channel0[i] = HEAP16[pData++] * 30517578125e-15;
                channel1[i] = HEAP16[pData++] * 30517578125e-15;
              }
            }
            buf.bytesPerSample = 2;
            buf.channels = 2;
            buf.length = size >> 2;
            break;
          case 65552:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(
                1,
                size >> 2,
                freq
              );
              var channel0 = audioBuf.getChannelData(0);
              pData >>= 2;
              for (var i = 0; i < size >> 2; ++i) {
                channel0[i] = HEAPF32[pData++];
              }
            }
            buf.bytesPerSample = 4;
            buf.channels = 1;
            buf.length = size >> 2;
            break;
          case 65553:
            if (size > 0) {
              audioBuf = AL.currentCtx.audioCtx.createBuffer(
                2,
                size >> 3,
                freq
              );
              var channel0 = audioBuf.getChannelData(0);
              var channel1 = audioBuf.getChannelData(1);
              pData >>= 2;
              for (var i = 0; i < size >> 3; ++i) {
                channel0[i] = HEAPF32[pData++];
                channel1[i] = HEAPF32[pData++];
              }
            }
            buf.bytesPerSample = 4;
            buf.channels = 2;
            buf.length = size >> 3;
            break;
          default:
            AL.currentCtx.err = 40963;
            return;
        }
        buf.frequency = freq;
        buf.audioBuf = audioBuf;
      } catch (e) {
        AL.currentCtx.err = 40963;
        return;
      }
    }
    function _alDeleteBuffers(count, pBufferIds) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(7, 1, count, pBufferIds);
      if (!AL.currentCtx) {
        return;
      }
      for (var i = 0; i < count; ++i) {
        var bufId = HEAP32[(pBufferIds + i * 4) >> 2];
        if (bufId === 0) {
          continue;
        }
        if (!AL.buffers[bufId]) {
          AL.currentCtx.err = 40961;
          return;
        }
        if (AL.buffers[bufId].refCount) {
          AL.currentCtx.err = 40964;
          return;
        }
      }
      for (var i = 0; i < count; ++i) {
        var bufId = HEAP32[(pBufferIds + i * 4) >> 2];
        if (bufId === 0) {
          continue;
        }
        AL.deviceRefCounts[AL.buffers[bufId].deviceId]--;
        delete AL.buffers[bufId];
        AL.freeIds.push(bufId);
      }
    }
    function _alSourcei(sourceId, param, value) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          8,
          1,
          sourceId,
          param,
          value
        );
      switch (param) {
        case 514:
        case 4097:
        case 4098:
        case 4103:
        case 4105:
        case 4128:
        case 4129:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 4628:
        case 8201:
        case 8202:
        case 53248:
          AL.setSourceParam('alSourcei', sourceId, param, value);
          break;
        default:
          AL.setSourceParam('alSourcei', sourceId, param, null);
          break;
      }
    }
    function _alDeleteSources(count, pSourceIds) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(9, 1, count, pSourceIds);
      if (!AL.currentCtx) {
        return;
      }
      for (var i = 0; i < count; ++i) {
        var srcId = HEAP32[(pSourceIds + i * 4) >> 2];
        if (!AL.currentCtx.sources[srcId]) {
          AL.currentCtx.err = 40961;
          return;
        }
      }
      for (var i = 0; i < count; ++i) {
        var srcId = HEAP32[(pSourceIds + i * 4) >> 2];
        AL.setSourceState(AL.currentCtx.sources[srcId], 4116);
        _alSourcei(srcId, 4105, 0);
        delete AL.currentCtx.sources[srcId];
        AL.freeIds.push(srcId);
      }
    }
    function _alGenBuffers(count, pBufferIds) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(10, 1, count, pBufferIds);
      if (!AL.currentCtx) {
        return;
      }
      for (var i = 0; i < count; ++i) {
        var buf = {
          deviceId: AL.currentCtx.deviceId,
          id: AL.newId(),
          refCount: 0,
          audioBuf: null,
          frequency: 0,
          bytesPerSample: 2,
          channels: 1,
          length: 0
        };
        AL.deviceRefCounts[buf.deviceId]++;
        AL.buffers[buf.id] = buf;
        HEAP32[(pBufferIds + i * 4) >> 2] = buf.id;
      }
    }
    function _alGenSources(count, pSourceIds) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(11, 1, count, pSourceIds);
      if (!AL.currentCtx) {
        return;
      }
      for (var i = 0; i < count; ++i) {
        var gain = AL.currentCtx.audioCtx.createGain();
        gain.connect(AL.currentCtx.gain);
        var src = {
          context: AL.currentCtx,
          id: AL.newId(),
          type: 4144,
          state: 4113,
          bufQueue: [AL.buffers[0]],
          audioQueue: [],
          looping: false,
          pitch: 1,
          dopplerShift: 1,
          gain: gain,
          minGain: 0,
          maxGain: 1,
          panner: null,
          bufsProcessed: 0,
          bufStartTime: Number.NEGATIVE_INFINITY,
          bufOffset: 0,
          relative: false,
          refDistance: 1,
          maxDistance: 3.40282e38,
          rolloffFactor: 1,
          position: [0, 0, 0],
          velocity: [0, 0, 0],
          direction: [0, 0, 0],
          coneOuterGain: 0,
          coneInnerAngle: 360,
          coneOuterAngle: 360,
          distanceModel: 53250,
          spatialize: 2,
          get playbackRate() {
            return this.pitch * this.dopplerShift;
          }
        };
        AL.currentCtx.sources[src.id] = src;
        HEAP32[(pSourceIds + i * 4) >> 2] = src.id;
      }
    }
    function _alGetEnumValue(pEnumName) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(12, 1, pEnumName);
      if (!AL.currentCtx) {
        return 0;
      }
      if (!pEnumName) {
        AL.currentCtx.err = 40963;
        return 0;
      }
      var name = UTF8ToString(pEnumName);
      switch (name) {
        case 'AL_BITS':
          return 8194;
        case 'AL_BUFFER':
          return 4105;
        case 'AL_BUFFERS_PROCESSED':
          return 4118;
        case 'AL_BUFFERS_QUEUED':
          return 4117;
        case 'AL_BYTE_OFFSET':
          return 4134;
        case 'AL_CHANNELS':
          return 8195;
        case 'AL_CONE_INNER_ANGLE':
          return 4097;
        case 'AL_CONE_OUTER_ANGLE':
          return 4098;
        case 'AL_CONE_OUTER_GAIN':
          return 4130;
        case 'AL_DIRECTION':
          return 4101;
        case 'AL_DISTANCE_MODEL':
          return 53248;
        case 'AL_DOPPLER_FACTOR':
          return 49152;
        case 'AL_DOPPLER_VELOCITY':
          return 49153;
        case 'AL_EXPONENT_DISTANCE':
          return 53253;
        case 'AL_EXPONENT_DISTANCE_CLAMPED':
          return 53254;
        case 'AL_EXTENSIONS':
          return 45060;
        case 'AL_FORMAT_MONO16':
          return 4353;
        case 'AL_FORMAT_MONO8':
          return 4352;
        case 'AL_FORMAT_STEREO16':
          return 4355;
        case 'AL_FORMAT_STEREO8':
          return 4354;
        case 'AL_FREQUENCY':
          return 8193;
        case 'AL_GAIN':
          return 4106;
        case 'AL_INITIAL':
          return 4113;
        case 'AL_INVALID':
          return -1;
        case 'AL_ILLEGAL_ENUM':
        case 'AL_INVALID_ENUM':
          return 40962;
        case 'AL_INVALID_NAME':
          return 40961;
        case 'AL_ILLEGAL_COMMAND':
        case 'AL_INVALID_OPERATION':
          return 40964;
        case 'AL_INVALID_VALUE':
          return 40963;
        case 'AL_INVERSE_DISTANCE':
          return 53249;
        case 'AL_INVERSE_DISTANCE_CLAMPED':
          return 53250;
        case 'AL_LINEAR_DISTANCE':
          return 53251;
        case 'AL_LINEAR_DISTANCE_CLAMPED':
          return 53252;
        case 'AL_LOOPING':
          return 4103;
        case 'AL_MAX_DISTANCE':
          return 4131;
        case 'AL_MAX_GAIN':
          return 4110;
        case 'AL_MIN_GAIN':
          return 4109;
        case 'AL_NONE':
          return 0;
        case 'AL_NO_ERROR':
          return 0;
        case 'AL_ORIENTATION':
          return 4111;
        case 'AL_OUT_OF_MEMORY':
          return 40965;
        case 'AL_PAUSED':
          return 4115;
        case 'AL_PENDING':
          return 8209;
        case 'AL_PITCH':
          return 4099;
        case 'AL_PLAYING':
          return 4114;
        case 'AL_POSITION':
          return 4100;
        case 'AL_PROCESSED':
          return 8210;
        case 'AL_REFERENCE_DISTANCE':
          return 4128;
        case 'AL_RENDERER':
          return 45059;
        case 'AL_ROLLOFF_FACTOR':
          return 4129;
        case 'AL_SAMPLE_OFFSET':
          return 4133;
        case 'AL_SEC_OFFSET':
          return 4132;
        case 'AL_SIZE':
          return 8196;
        case 'AL_SOURCE_RELATIVE':
          return 514;
        case 'AL_SOURCE_STATE':
          return 4112;
        case 'AL_SOURCE_TYPE':
          return 4135;
        case 'AL_SPEED_OF_SOUND':
          return 49155;
        case 'AL_STATIC':
          return 4136;
        case 'AL_STOPPED':
          return 4116;
        case 'AL_STREAMING':
          return 4137;
        case 'AL_UNDETERMINED':
          return 4144;
        case 'AL_UNUSED':
          return 8208;
        case 'AL_VELOCITY':
          return 4102;
        case 'AL_VENDOR':
          return 45057;
        case 'AL_VERSION':
          return 45058;
        case 'AL_AUTO_SOFT':
          return 2;
        case 'AL_SOURCE_DISTANCE_MODEL':
          return 512;
        case 'AL_SOURCE_SPATIALIZE_SOFT':
          return 4628;
        case 'AL_LOOP_POINTS_SOFT':
          return 8213;
        case 'AL_BYTE_LENGTH_SOFT':
          return 8201;
        case 'AL_SAMPLE_LENGTH_SOFT':
          return 8202;
        case 'AL_SEC_LENGTH_SOFT':
          return 8203;
        case 'AL_FORMAT_MONO_FLOAT32':
          return 65552;
        case 'AL_FORMAT_STEREO_FLOAT32':
          return 65553;
        default:
          AL.currentCtx.err = 40963;
          return 0;
      }
    }
    function _alGetError() {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(13, 1);
      if (!AL.currentCtx) {
        return 40964;
      } else {
        var err = AL.currentCtx.err;
        AL.currentCtx.err = 0;
        return err;
      }
    }
    function _alGetSourcef(sourceId, param, pValue) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          14,
          1,
          sourceId,
          param,
          pValue
        );
      var val = AL.getSourceParam('alGetSourcef', sourceId, param);
      if (val === null) {
        return;
      }
      if (!pValue) {
        AL.currentCtx.err = 40963;
        return;
      }
      switch (param) {
        case 4097:
        case 4098:
        case 4099:
        case 4106:
        case 4109:
        case 4110:
        case 4128:
        case 4129:
        case 4130:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 8203:
          HEAPF32[pValue >> 2] = val;
          break;
        default:
          AL.currentCtx.err = 40962;
          return;
      }
    }
    function _alGetSourcei(sourceId, param, pValue) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          15,
          1,
          sourceId,
          param,
          pValue
        );
      var val = AL.getSourceParam('alGetSourcei', sourceId, param);
      if (val === null) {
        return;
      }
      if (!pValue) {
        AL.currentCtx.err = 40963;
        return;
      }
      switch (param) {
        case 514:
        case 4097:
        case 4098:
        case 4103:
        case 4105:
        case 4112:
        case 4117:
        case 4118:
        case 4128:
        case 4129:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 4135:
        case 4628:
        case 8201:
        case 8202:
        case 53248:
          HEAP32[pValue >> 2] = val;
          break;
        default:
          AL.currentCtx.err = 40962;
          return;
      }
    }
    function _alIsSource(sourceId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(16, 1, sourceId);
      if (!AL.currentCtx) {
        return false;
      }
      if (!AL.currentCtx.sources[sourceId]) {
        return false;
      } else {
        return true;
      }
    }
    function _alListenerfv(param, pValues) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(17, 1, param, pValues);
      if (!AL.currentCtx) {
        return;
      }
      if (!pValues) {
        AL.currentCtx.err = 40963;
        return;
      }
      switch (param) {
        case 4100:
        case 4102:
          AL.paramArray[0] = HEAPF32[pValues >> 2];
          AL.paramArray[1] = HEAPF32[(pValues + 4) >> 2];
          AL.paramArray[2] = HEAPF32[(pValues + 8) >> 2];
          AL.setListenerParam('alListenerfv', param, AL.paramArray);
          break;
        case 4111:
          AL.paramArray[0] = HEAPF32[pValues >> 2];
          AL.paramArray[1] = HEAPF32[(pValues + 4) >> 2];
          AL.paramArray[2] = HEAPF32[(pValues + 8) >> 2];
          AL.paramArray[3] = HEAPF32[(pValues + 12) >> 2];
          AL.paramArray[4] = HEAPF32[(pValues + 16) >> 2];
          AL.paramArray[5] = HEAPF32[(pValues + 20) >> 2];
          AL.setListenerParam('alListenerfv', param, AL.paramArray);
          break;
        default:
          AL.setListenerParam('alListenerfv', param, null);
          break;
      }
    }
    function _alSourcePlay(sourceId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(18, 1, sourceId);
      if (!AL.currentCtx) {
        return;
      }
      var src = AL.currentCtx.sources[sourceId];
      if (!src) {
        AL.currentCtx.err = 40961;
        return;
      }
      AL.setSourceState(src, 4114);
    }
    function _alSourceQueueBuffers(sourceId, count, pBufferIds) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          19,
          1,
          sourceId,
          count,
          pBufferIds
        );
      if (!AL.currentCtx) {
        return;
      }
      var src = AL.currentCtx.sources[sourceId];
      if (!src) {
        AL.currentCtx.err = 40961;
        return;
      }
      if (src.type === 4136) {
        AL.currentCtx.err = 40964;
        return;
      }
      if (count === 0) {
        return;
      }
      var templateBuf = AL.buffers[0];
      for (var i = 0; i < src.bufQueue.length; i++) {
        if (src.bufQueue[i].id !== 0) {
          templateBuf = src.bufQueue[i];
          break;
        }
      }
      for (var i = 0; i < count; ++i) {
        var bufId = HEAP32[(pBufferIds + i * 4) >> 2];
        var buf = AL.buffers[bufId];
        if (!buf) {
          AL.currentCtx.err = 40961;
          return;
        }
        if (
          templateBuf.id !== 0 &&
          (buf.frequency !== templateBuf.frequency ||
            buf.bytesPerSample !== templateBuf.bytesPerSample ||
            buf.channels !== templateBuf.channels)
        ) {
          AL.currentCtx.err = 40964;
        }
      }
      if (src.bufQueue.length === 1 && src.bufQueue[0].id === 0) {
        src.bufQueue.length = 0;
      }
      src.type = 4137;
      for (var i = 0; i < count; ++i) {
        var bufId = HEAP32[(pBufferIds + i * 4) >> 2];
        var buf = AL.buffers[bufId];
        buf.refCount++;
        src.bufQueue.push(buf);
      }
      if (src.looping) {
        AL.cancelPendingSourceAudio(src);
      }
      AL.initSourcePanner(src);
      AL.scheduleSourceAudio(src);
    }
    function _alSourceStop(sourceId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(20, 1, sourceId);
      if (!AL.currentCtx) {
        return;
      }
      var src = AL.currentCtx.sources[sourceId];
      if (!src) {
        AL.currentCtx.err = 40961;
        return;
      }
      AL.setSourceState(src, 4116);
    }
    function _alSourceUnqueueBuffers(sourceId, count, pBufferIds) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          21,
          1,
          sourceId,
          count,
          pBufferIds
        );
      if (!AL.currentCtx) {
        return;
      }
      var src = AL.currentCtx.sources[sourceId];
      if (!src) {
        AL.currentCtx.err = 40961;
        return;
      }
      if (
        count >
        (src.bufQueue.length === 1 && src.bufQueue[0].id === 0
          ? 0
          : src.bufsProcessed)
      ) {
        AL.currentCtx.err = 40963;
        return;
      }
      if (count === 0) {
        return;
      }
      for (var i = 0; i < count; i++) {
        var buf = src.bufQueue.shift();
        buf.refCount--;
        HEAP32[(pBufferIds + i * 4) >> 2] = buf.id;
        src.bufsProcessed--;
      }
      if (src.bufQueue.length === 0) {
        src.bufQueue.push(AL.buffers[0]);
      }
      AL.initSourcePanner(src);
      AL.scheduleSourceAudio(src);
    }
    function _alSourcef(sourceId, param, value) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          22,
          1,
          sourceId,
          param,
          value
        );
      switch (param) {
        case 4097:
        case 4098:
        case 4099:
        case 4106:
        case 4109:
        case 4110:
        case 4128:
        case 4129:
        case 4130:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 8203:
          AL.setSourceParam('alSourcef', sourceId, param, value);
          break;
        default:
          AL.setSourceParam('alSourcef', sourceId, param, null);
          break;
      }
    }
    function _alSourcefv(sourceId, param, pValues) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          23,
          1,
          sourceId,
          param,
          pValues
        );
      if (!AL.currentCtx) {
        return;
      }
      if (!pValues) {
        AL.currentCtx.err = 40963;
        return;
      }
      switch (param) {
        case 4097:
        case 4098:
        case 4099:
        case 4106:
        case 4109:
        case 4110:
        case 4128:
        case 4129:
        case 4130:
        case 4131:
        case 4132:
        case 4133:
        case 4134:
        case 8203:
          var val = HEAPF32[pValues >> 2];
          AL.setSourceParam('alSourcefv', sourceId, param, val);
          break;
        case 4100:
        case 4101:
        case 4102:
          AL.paramArray[0] = HEAPF32[pValues >> 2];
          AL.paramArray[1] = HEAPF32[(pValues + 4) >> 2];
          AL.paramArray[2] = HEAPF32[(pValues + 8) >> 2];
          AL.setSourceParam('alSourcefv', sourceId, param, AL.paramArray);
          break;
        default:
          AL.setSourceParam('alSourcefv', sourceId, param, null);
          break;
      }
    }
    function _alcCaptureCloseDevice(deviceId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(24, 1, deviceId);
      var c = AL.requireValidCaptureDevice(deviceId, 'alcCaptureCloseDevice');
      if (!c) return false;
      delete AL.captures[deviceId];
      AL.freeIds.push(deviceId);
      if (c.mediaStreamSourceNode) c.mediaStreamSourceNode.disconnect();
      if (c.mergerNode) c.mergerNode.disconnect();
      if (c.splitterNode) c.splitterNode.disconnect();
      if (c.scriptProcessorNode) c.scriptProcessorNode.disconnect();
      if (c.mediaStream) {
        c.mediaStream.getTracks().forEach(function (track) {
          track.stop();
        });
      }
      delete c.buffers;
      c.capturedFrameCount = 0;
      c.isCapturing = false;
      return true;
    }
    function listenOnce(object, event, func) {
      object.addEventListener(event, func, { once: true });
    }
    function autoResumeAudioContext(ctx, elements) {
      if (!elements) {
        elements = [document, document.getElementById('canvas')];
      }
      ['keydown', 'mousedown', 'touchstart'].forEach(function (event) {
        elements.forEach(function (element) {
          if (element) {
            listenOnce(element, event, function () {
              if (ctx.state === 'suspended') ctx.resume();
            });
          }
        });
      });
    }
    function _alcCaptureOpenDevice(
      pDeviceName,
      requestedSampleRate,
      format,
      bufferFrameCapacity
    ) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          25,
          1,
          pDeviceName,
          requestedSampleRate,
          format,
          bufferFrameCapacity
        );
      var resolvedDeviceName = AL.CAPTURE_DEVICE_NAME;
      if (pDeviceName !== 0) {
        resolvedDeviceName = UTF8ToString(pDeviceName);
        if (resolvedDeviceName !== AL.CAPTURE_DEVICE_NAME) {
          AL.alcErr = 40965;
          return 0;
        }
      }
      if (bufferFrameCapacity < 0) {
        AL.alcErr = 40964;
        return 0;
      }
      navigator.getUserMedia =
        navigator.getUserMedia ||
        navigator.webkitGetUserMedia ||
        navigator.mozGetUserMedia ||
        navigator.msGetUserMedia;
      var has_getUserMedia =
        navigator.getUserMedia ||
        (navigator.mediaDevices && navigator.mediaDevices.getUserMedia);
      if (!has_getUserMedia) {
        AL.alcErr = 40965;
        return 0;
      }
      var AudioContext = window.AudioContext || window.webkitAudioContext;
      if (!AL.sharedCaptureAudioCtx) {
        try {
          AL.sharedCaptureAudioCtx = new AudioContext();
        } catch (e) {
          AL.alcErr = 40965;
          return 0;
        }
      }
      autoResumeAudioContext(AL.sharedCaptureAudioCtx);
      var outputChannelCount;
      switch (format) {
        case 65552:
        case 4353:
        case 4352:
          outputChannelCount = 1;
          break;
        case 65553:
        case 4355:
        case 4354:
          outputChannelCount = 2;
          break;
        default:
          AL.alcErr = 40964;
          return 0;
      }
      function newF32Array(cap) {
        return new Float32Array(cap);
      }
      function newI16Array(cap) {
        return new Int16Array(cap);
      }
      function newU8Array(cap) {
        return new Uint8Array(cap);
      }
      var requestedSampleType;
      var newSampleArray;
      switch (format) {
        case 65552:
        case 65553:
          requestedSampleType = 'f32';
          newSampleArray = newF32Array;
          break;
        case 4353:
        case 4355:
          requestedSampleType = 'i16';
          newSampleArray = newI16Array;
          break;
        case 4352:
        case 4354:
          requestedSampleType = 'u8';
          newSampleArray = newU8Array;
          break;
      }
      var buffers = [];
      try {
        for (var chan = 0; chan < outputChannelCount; ++chan) {
          buffers[chan] = newSampleArray(bufferFrameCapacity);
        }
      } catch (e) {
        AL.alcErr = 40965;
        return 0;
      }
      var newCapture = {
        audioCtx: AL.sharedCaptureAudioCtx,
        deviceName: resolvedDeviceName,
        requestedSampleRate: requestedSampleRate,
        requestedSampleType: requestedSampleType,
        outputChannelCount: outputChannelCount,
        inputChannelCount: null,
        mediaStreamError: null,
        mediaStreamSourceNode: null,
        mediaStream: null,
        mergerNode: null,
        splitterNode: null,
        scriptProcessorNode: null,
        isCapturing: false,
        buffers: buffers,
        get bufferFrameCapacity() {
          return buffers[0].length;
        },
        capturePlayhead: 0,
        captureReadhead: 0,
        capturedFrameCount: 0
      };
      var onError = function (mediaStreamError) {
        newCapture.mediaStreamError = mediaStreamError;
      };
      var onSuccess = function (mediaStream) {
        newCapture.mediaStreamSourceNode =
          newCapture.audioCtx.createMediaStreamSource(mediaStream);
        newCapture.mediaStream = mediaStream;
        var inputChannelCount = 1;
        switch (newCapture.mediaStreamSourceNode.channelCountMode) {
          case 'max':
            inputChannelCount = outputChannelCount;
            break;
          case 'clamped-max':
            inputChannelCount = Math.min(
              outputChannelCount,
              newCapture.mediaStreamSourceNode.channelCount
            );
            break;
          case 'explicit':
            inputChannelCount = newCapture.mediaStreamSourceNode.channelCount;
            break;
        }
        newCapture.inputChannelCount = inputChannelCount;
        var processorFrameCount = 512;
        newCapture.scriptProcessorNode =
          newCapture.audioCtx.createScriptProcessor(
            processorFrameCount,
            inputChannelCount,
            outputChannelCount
          );
        if (inputChannelCount > outputChannelCount) {
          newCapture.mergerNode =
            newCapture.audioCtx.createChannelMerger(inputChannelCount);
          newCapture.mediaStreamSourceNode.connect(newCapture.mergerNode);
          newCapture.mergerNode.connect(newCapture.scriptProcessorNode);
        } else if (inputChannelCount < outputChannelCount) {
          newCapture.splitterNode =
            newCapture.audioCtx.createChannelSplitter(outputChannelCount);
          newCapture.mediaStreamSourceNode.connect(newCapture.splitterNode);
          newCapture.splitterNode.connect(newCapture.scriptProcessorNode);
        } else {
          newCapture.mediaStreamSourceNode.connect(
            newCapture.scriptProcessorNode
          );
        }
        newCapture.scriptProcessorNode.connect(newCapture.audioCtx.destination);
        newCapture.scriptProcessorNode.onaudioprocess = function (
          audioProcessingEvent
        ) {
          if (!newCapture.isCapturing) {
            return;
          }
          var c = newCapture;
          var srcBuf = audioProcessingEvent.inputBuffer;
          switch (format) {
            case 65552:
              var channel0 = srcBuf.getChannelData(0);
              for (var i = 0; i < srcBuf.length; ++i) {
                var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
                c.buffers[0][wi] = channel0[i];
              }
              break;
            case 65553:
              var channel0 = srcBuf.getChannelData(0);
              var channel1 = srcBuf.getChannelData(1);
              for (var i = 0; i < srcBuf.length; ++i) {
                var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
                c.buffers[0][wi] = channel0[i];
                c.buffers[1][wi] = channel1[i];
              }
              break;
            case 4353:
              var channel0 = srcBuf.getChannelData(0);
              for (var i = 0; i < srcBuf.length; ++i) {
                var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
                c.buffers[0][wi] = channel0[i] * 32767;
              }
              break;
            case 4355:
              var channel0 = srcBuf.getChannelData(0);
              var channel1 = srcBuf.getChannelData(1);
              for (var i = 0; i < srcBuf.length; ++i) {
                var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
                c.buffers[0][wi] = channel0[i] * 32767;
                c.buffers[1][wi] = channel1[i] * 32767;
              }
              break;
            case 4352:
              var channel0 = srcBuf.getChannelData(0);
              for (var i = 0; i < srcBuf.length; ++i) {
                var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
                c.buffers[0][wi] = (channel0[i] + 1) * 127;
              }
              break;
            case 4354:
              var channel0 = srcBuf.getChannelData(0);
              var channel1 = srcBuf.getChannelData(1);
              for (var i = 0; i < srcBuf.length; ++i) {
                var wi = (c.capturePlayhead + i) % c.bufferFrameCapacity;
                c.buffers[0][wi] = (channel0[i] + 1) * 127;
                c.buffers[1][wi] = (channel1[i] + 1) * 127;
              }
              break;
          }
          c.capturePlayhead += srcBuf.length;
          c.capturePlayhead %= c.bufferFrameCapacity;
          c.capturedFrameCount += srcBuf.length;
          c.capturedFrameCount = Math.min(
            c.capturedFrameCount,
            c.bufferFrameCapacity
          );
        };
      };
      if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
        navigator.mediaDevices
          .getUserMedia({ audio: true })
          .then(onSuccess)
          .catch(onError);
      } else {
        navigator.getUserMedia({ audio: true }, onSuccess, onError);
      }
      var id = AL.newId();
      AL.captures[id] = newCapture;
      return id;
    }
    function _alcCaptureSamples(deviceId, pFrames, requestedFrameCount) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          26,
          1,
          deviceId,
          pFrames,
          requestedFrameCount
        );
      var c = AL.requireValidCaptureDevice(deviceId, 'alcCaptureSamples');
      if (!c) return;
      var dstfreq = c.requestedSampleRate;
      var srcfreq = c.audioCtx.sampleRate;
      var fratio = srcfreq / dstfreq;
      if (
        requestedFrameCount < 0 ||
        requestedFrameCount > c.capturedFrameCount / fratio
      ) {
        err('alcCaptureSamples() with invalid bufferSize');
        AL.alcErr = 40964;
        return;
      }
      function setF32Sample(i, sample) {
        HEAPF32[(pFrames + 4 * i) >> 2] = sample;
      }
      function setI16Sample(i, sample) {
        HEAP16[(pFrames + 2 * i) >> 1] = sample;
      }
      function setU8Sample(i, sample) {
        HEAP8[(pFrames + i) >> 0] = sample;
      }
      var setSample;
      switch (c.requestedSampleType) {
        case 'f32':
          setSample = setF32Sample;
          break;
        case 'i16':
          setSample = setI16Sample;
          break;
        case 'u8':
          setSample = setU8Sample;
          break;
        default:
          return;
      }
      if (Math.floor(fratio) == fratio) {
        for (var i = 0, frame_i = 0; frame_i < requestedFrameCount; ++frame_i) {
          for (var chan = 0; chan < c.buffers.length; ++chan, ++i) {
            setSample(i, c.buffers[chan][c.captureReadhead]);
          }
          c.captureReadhead =
            (fratio + c.captureReadhead) % c.bufferFrameCapacity;
        }
      } else {
        for (var i = 0, frame_i = 0; frame_i < requestedFrameCount; ++frame_i) {
          var lefti = Math.floor(c.captureReadhead);
          var righti = Math.ceil(c.captureReadhead);
          var d = c.captureReadhead - lefti;
          for (var chan = 0; chan < c.buffers.length; ++chan, ++i) {
            var lefts = c.buffers[chan][lefti];
            var rights = c.buffers[chan][righti];
            setSample(i, (1 - d) * lefts + d * rights);
          }
          c.captureReadhead =
            (c.captureReadhead + fratio) % c.bufferFrameCapacity;
        }
      }
      c.capturedFrameCount = 0;
    }
    function _alcCaptureStart(deviceId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(27, 1, deviceId);
      var c = AL.requireValidCaptureDevice(deviceId, 'alcCaptureStart');
      if (!c) return;
      if (c.isCapturing) {
        return;
      }
      c.isCapturing = true;
      c.capturedFrameCount = 0;
      c.capturePlayhead = 0;
    }
    function _alcCaptureStop(deviceId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(28, 1, deviceId);
      var c = AL.requireValidCaptureDevice(deviceId, 'alcCaptureStop');
      if (!c) return;
      c.isCapturing = false;
    }
    function _alcCloseDevice(deviceId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(29, 1, deviceId);
      if (
        !(deviceId in AL.deviceRefCounts) ||
        AL.deviceRefCounts[deviceId] > 0
      ) {
        return 0;
      }
      delete AL.deviceRefCounts[deviceId];
      AL.freeIds.push(deviceId);
      return 1;
    }
    function _alcCreateContext(deviceId, pAttrList) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(30, 1, deviceId, pAttrList);
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = 40961;
        return 0;
      }
      var options = null;
      var attrs = [];
      var hrtf = null;
      pAttrList >>= 2;
      if (pAttrList) {
        var attr = 0;
        var val = 0;
        while (true) {
          attr = HEAP32[pAttrList++];
          attrs.push(attr);
          if (attr === 0) {
            break;
          }
          val = HEAP32[pAttrList++];
          attrs.push(val);
          switch (attr) {
            case 4103:
              if (!options) {
                options = {};
              }
              options.sampleRate = val;
              break;
            case 4112:
            case 4113:
              break;
            case 6546:
              switch (val) {
                case 0:
                  hrtf = false;
                  break;
                case 1:
                  hrtf = true;
                  break;
                case 2:
                  break;
                default:
                  AL.alcErr = 40964;
                  return 0;
              }
              break;
            case 6550:
              if (val !== 0) {
                AL.alcErr = 40964;
                return 0;
              }
              break;
            default:
              AL.alcErr = 40964;
              return 0;
          }
        }
      }
      var AudioContext = window.AudioContext || window.webkitAudioContext;
      var ac = null;
      try {
        if (options) {
          ac = new AudioContext(options);
        } else {
          ac = new AudioContext();
        }
      } catch (e) {
        if (e.name === 'NotSupportedError') {
          AL.alcErr = 40964;
        } else {
          AL.alcErr = 40961;
        }
        return 0;
      }
      autoResumeAudioContext(ac);
      if (typeof ac.createGain === 'undefined') {
        ac.createGain = ac.createGainNode;
      }
      var gain = ac.createGain();
      gain.connect(ac.destination);
      var ctx = {
        deviceId: deviceId,
        id: AL.newId(),
        attrs: attrs,
        audioCtx: ac,
        listener: {
          position: [0, 0, 0],
          velocity: [0, 0, 0],
          direction: [0, 0, 0],
          up: [0, 0, 0]
        },
        sources: [],
        interval: setInterval(function () {
          AL.scheduleContextAudio(ctx);
        }, AL.QUEUE_INTERVAL),
        gain: gain,
        distanceModel: 53250,
        speedOfSound: 343.3,
        dopplerFactor: 1,
        sourceDistanceModel: false,
        hrtf: hrtf || false,
        _err: 0,
        get err() {
          return this._err;
        },
        set err(val) {
          if (this._err === 0 || val === 0) {
            this._err = val;
          }
        }
      };
      AL.deviceRefCounts[deviceId]++;
      AL.contexts[ctx.id] = ctx;
      if (hrtf !== null) {
        for (var ctxId in AL.contexts) {
          var c = AL.contexts[ctxId];
          if (c.deviceId === deviceId) {
            c.hrtf = hrtf;
            AL.updateContextGlobal(c);
          }
        }
      }
      return ctx.id;
    }
    function _alcDestroyContext(contextId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(31, 1, contextId);
      var ctx = AL.contexts[contextId];
      if (AL.currentCtx === ctx) {
        AL.alcErr = 40962;
        return;
      }
      if (AL.contexts[contextId].interval) {
        clearInterval(AL.contexts[contextId].interval);
      }
      AL.deviceRefCounts[ctx.deviceId]--;
      delete AL.contexts[contextId];
      AL.freeIds.push(contextId);
    }
    function _alcGetContextsDevice(contextId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(32, 1, contextId);
      if (contextId in AL.contexts) {
        return AL.contexts[contextId].deviceId;
      } else {
        return 0;
      }
    }
    function _alcGetCurrentContext() {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(33, 1);
      if (AL.currentCtx !== null) {
        return AL.currentCtx.id;
      } else {
        return 0;
      }
    }
    function _alcGetEnumValue(deviceId, pEnumName) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(34, 1, deviceId, pEnumName);
      if (deviceId !== 0 && !(deviceId in AL.deviceRefCounts)) {
        return 0;
      } else if (!pEnumName) {
        AL.alcErr = 40964;
        return 0;
      }
      var name = UTF8ToString(pEnumName);
      switch (name) {
        case 'ALC_NO_ERROR':
          return 0;
        case 'ALC_INVALID_DEVICE':
          return 40961;
        case 'ALC_INVALID_CONTEXT':
          return 40962;
        case 'ALC_INVALID_ENUM':
          return 40963;
        case 'ALC_INVALID_VALUE':
          return 40964;
        case 'ALC_OUT_OF_MEMORY':
          return 40965;
        case 'ALC_MAJOR_VERSION':
          return 4096;
        case 'ALC_MINOR_VERSION':
          return 4097;
        case 'ALC_ATTRIBUTES_SIZE':
          return 4098;
        case 'ALC_ALL_ATTRIBUTES':
          return 4099;
        case 'ALC_DEFAULT_DEVICE_SPECIFIER':
          return 4100;
        case 'ALC_DEVICE_SPECIFIER':
          return 4101;
        case 'ALC_EXTENSIONS':
          return 4102;
        case 'ALC_FREQUENCY':
          return 4103;
        case 'ALC_REFRESH':
          return 4104;
        case 'ALC_SYNC':
          return 4105;
        case 'ALC_MONO_SOURCES':
          return 4112;
        case 'ALC_STEREO_SOURCES':
          return 4113;
        case 'ALC_CAPTURE_DEVICE_SPECIFIER':
          return 784;
        case 'ALC_CAPTURE_DEFAULT_DEVICE_SPECIFIER':
          return 785;
        case 'ALC_CAPTURE_SAMPLES':
          return 786;
        case 'ALC_HRTF_SOFT':
          return 6546;
        case 'ALC_HRTF_ID_SOFT':
          return 6550;
        case 'ALC_DONT_CARE_SOFT':
          return 2;
        case 'ALC_HRTF_STATUS_SOFT':
          return 6547;
        case 'ALC_NUM_HRTF_SPECIFIERS_SOFT':
          return 6548;
        case 'ALC_HRTF_SPECIFIER_SOFT':
          return 6549;
        case 'ALC_HRTF_DISABLED_SOFT':
          return 0;
        case 'ALC_HRTF_ENABLED_SOFT':
          return 1;
        case 'ALC_HRTF_DENIED_SOFT':
          return 2;
        case 'ALC_HRTF_REQUIRED_SOFT':
          return 3;
        case 'ALC_HRTF_HEADPHONES_DETECTED_SOFT':
          return 4;
        case 'ALC_HRTF_UNSUPPORTED_FORMAT_SOFT':
          return 5;
        default:
          AL.alcErr = 40964;
          return 0;
      }
    }
    function _alcGetError(deviceId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(35, 1, deviceId);
      var err = AL.alcErr;
      AL.alcErr = 0;
      return err;
    }
    function _alcGetIntegerv(deviceId, param, size, pValues) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          36,
          1,
          deviceId,
          param,
          size,
          pValues
        );
      if (size === 0 || !pValues) {
        return;
      }
      switch (param) {
        case 4096:
          HEAP32[pValues >> 2] = 1;
          break;
        case 4097:
          HEAP32[pValues >> 2] = 1;
          break;
        case 4098:
          if (!(deviceId in AL.deviceRefCounts)) {
            AL.alcErr = 40961;
            return;
          }
          if (!AL.currentCtx) {
            AL.alcErr = 40962;
            return;
          }
          HEAP32[pValues >> 2] = AL.currentCtx.attrs.length;
          break;
        case 4099:
          if (!(deviceId in AL.deviceRefCounts)) {
            AL.alcErr = 40961;
            return;
          }
          if (!AL.currentCtx) {
            AL.alcErr = 40962;
            return;
          }
          for (var i = 0; i < AL.currentCtx.attrs.length; i++) {
            HEAP32[(pValues + i * 4) >> 2] = AL.currentCtx.attrs[i];
          }
          break;
        case 4103:
          if (!(deviceId in AL.deviceRefCounts)) {
            AL.alcErr = 40961;
            return;
          }
          if (!AL.currentCtx) {
            AL.alcErr = 40962;
            return;
          }
          HEAP32[pValues >> 2] = AL.currentCtx.audioCtx.sampleRate;
          break;
        case 4112:
        case 4113:
          if (!(deviceId in AL.deviceRefCounts)) {
            AL.alcErr = 40961;
            return;
          }
          if (!AL.currentCtx) {
            AL.alcErr = 40962;
            return;
          }
          HEAP32[pValues >> 2] = 2147483647;
          break;
        case 6546:
        case 6547:
          if (!(deviceId in AL.deviceRefCounts)) {
            AL.alcErr = 40961;
            return;
          }
          var hrtfStatus = 0;
          for (var ctxId in AL.contexts) {
            var ctx = AL.contexts[ctxId];
            if (ctx.deviceId === deviceId) {
              hrtfStatus = ctx.hrtf ? 1 : 0;
            }
          }
          HEAP32[pValues >> 2] = hrtfStatus;
          break;
        case 6548:
          if (!(deviceId in AL.deviceRefCounts)) {
            AL.alcErr = 40961;
            return;
          }
          HEAP32[pValues >> 2] = 1;
          break;
        case 131075:
          if (!(deviceId in AL.deviceRefCounts)) {
            AL.alcErr = 40961;
            return;
          }
          if (!AL.currentCtx) {
            AL.alcErr = 40962;
            return;
          }
          HEAP32[pValues >> 2] = 1;
        case 786:
          var c = AL.requireValidCaptureDevice(deviceId, 'alcGetIntegerv');
          if (!c) {
            return;
          }
          var n = c.capturedFrameCount;
          var dstfreq = c.requestedSampleRate;
          var srcfreq = c.audioCtx.sampleRate;
          var nsamples = Math.floor(n * (dstfreq / srcfreq));
          HEAP32[pValues >> 2] = nsamples;
          break;
        default:
          AL.alcErr = 40963;
          return;
      }
    }
    function _alcGetString(deviceId, param) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(37, 1, deviceId, param);
      if (AL.alcStringCache[param]) {
        return AL.alcStringCache[param];
      }
      var ret;
      switch (param) {
        case 0:
          ret = 'No Error';
          break;
        case 40961:
          ret = 'Invalid Device';
          break;
        case 40962:
          ret = 'Invalid Context';
          break;
        case 40963:
          ret = 'Invalid Enum';
          break;
        case 40964:
          ret = 'Invalid Value';
          break;
        case 40965:
          ret = 'Out of Memory';
          break;
        case 4100:
          if (
            typeof AudioContext !== 'undefined' ||
            typeof webkitAudioContext !== 'undefined'
          ) {
            ret = AL.DEVICE_NAME;
          } else {
            return 0;
          }
          break;
        case 4101:
          if (
            typeof AudioContext !== 'undefined' ||
            typeof webkitAudioContext !== 'undefined'
          ) {
            ret = AL.DEVICE_NAME.concat('\0');
          } else {
            ret = '\0';
          }
          break;
        case 785:
          ret = AL.CAPTURE_DEVICE_NAME;
          break;
        case 784:
          if (deviceId === 0) ret = AL.CAPTURE_DEVICE_NAME.concat('\0');
          else {
            var c = AL.requireValidCaptureDevice(deviceId, 'alcGetString');
            if (!c) {
              return 0;
            }
            ret = c.deviceName;
          }
          break;
        case 4102:
          if (!deviceId) {
            AL.alcErr = 40961;
            return 0;
          }
          ret = '';
          for (var ext in AL.ALC_EXTENSIONS) {
            ret = ret.concat(ext);
            ret = ret.concat(' ');
          }
          ret = ret.trim();
          break;
        default:
          AL.alcErr = 40963;
          return 0;
      }
      ret = allocate(intArrayFromString(ret), ALLOC_NORMAL);
      AL.alcStringCache[param] = ret;
      return ret;
    }
    function _alcIsExtensionPresent(deviceId, pExtName) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(38, 1, deviceId, pExtName);
      var name = UTF8ToString(pExtName);
      return AL.ALC_EXTENSIONS[name] ? 1 : 0;
    }
    function _alcMakeContextCurrent(contextId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(39, 1, contextId);
      if (contextId === 0) {
        AL.currentCtx = null;
        return 0;
      } else {
        AL.currentCtx = AL.contexts[contextId];
        return 1;
      }
    }
    function _alcOpenDevice(pDeviceName) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(40, 1, pDeviceName);
      if (pDeviceName) {
        var name = UTF8ToString(pDeviceName);
        if (name !== AL.DEVICE_NAME) {
          return 0;
        }
      }
      if (
        typeof AudioContext !== 'undefined' ||
        typeof webkitAudioContext !== 'undefined'
      ) {
        var deviceId = AL.newId();
        AL.deviceRefCounts[deviceId] = 0;
        return deviceId;
      } else {
        return 0;
      }
    }
    function _alcProcessContext(contextId) {}
    function _alcSuspendContext(contextId) {}
    function _clock() {
      if (_clock.start === undefined) _clock.start = Date.now();
      return ((Date.now() - _clock.start) * (1e6 / 1e3)) | 0;
    }
    function _emscripten_alcDevicePauseSOFT(deviceId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(41, 1, deviceId);
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = 40961;
        return;
      }
      if (AL.paused) {
        return;
      }
      AL.paused = true;
      for (var ctxId in AL.contexts) {
        var ctx = AL.contexts[ctxId];
        if (ctx.deviceId !== deviceId) {
          continue;
        }
        ctx.audioCtx.suspend();
        clearInterval(ctx.interval);
        ctx.interval = null;
      }
    }
    function _emscripten_alcDeviceResumeSOFT(deviceId) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(42, 1, deviceId);
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = 40961;
        return;
      }
      if (!AL.paused) {
        return;
      }
      AL.paused = false;
      for (var ctxId in AL.contexts) {
        var ctx = AL.contexts[ctxId];
        if (ctx.deviceId !== deviceId) {
          continue;
        }
        ctx.interval = setInterval(function () {
          AL.scheduleContextAudio(ctx);
        }, AL.QUEUE_INTERVAL);
        ctx.audioCtx.resume();
      }
    }
    function _emscripten_alcGetStringiSOFT(deviceId, param, index) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          43,
          1,
          deviceId,
          param,
          index
        );
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = 40961;
        return 0;
      }
      if (AL.alcStringCache[param]) {
        return AL.alcStringCache[param];
      }
      var ret;
      switch (param) {
        case 6549:
          if (index === 0) {
            ret = 'Web Audio HRTF';
          } else {
            AL.alcErr = 40964;
            return 0;
          }
          break;
        default:
          if (index === 0) {
            return _alcGetString(deviceId, param);
          } else {
            AL.alcErr = 40963;
            return 0;
          }
      }
      ret = allocate(intArrayFromString(ret), ALLOC_NORMAL);
      AL.alcStringCache[param] = ret;
      return ret;
    }
    function _emscripten_alcResetDeviceSOFT(deviceId, pAttrList) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(44, 1, deviceId, pAttrList);
      if (!(deviceId in AL.deviceRefCounts)) {
        AL.alcErr = 40961;
        return 0;
      }
      var hrtf = null;
      pAttrList >>= 2;
      if (pAttrList) {
        var attr = 0;
        var val = 0;
        while (true) {
          attr = HEAP32[pAttrList++];
          if (attr === 0) {
            break;
          }
          val = HEAP32[pAttrList++];
          switch (attr) {
            case 6546:
              if (val === 1) {
                hrtf = true;
              } else if (val === 0) {
                hrtf = false;
              }
              break;
          }
        }
      }
      if (hrtf !== null) {
        for (var ctxId in AL.contexts) {
          var ctx = AL.contexts[ctxId];
          if (ctx.deviceId === deviceId) {
            ctx.hrtf = hrtf;
            AL.updateContextGlobal(ctx);
          }
        }
      }
      return 1;
    }
    var readAsmConstArgsArray = [];
    function readAsmConstArgs(sigPtr, buf) {
      readAsmConstArgsArray.length = 0;
      var ch;
      buf >>= 2;
      while ((ch = HEAPU8[sigPtr++])) {
        var double = ch < 105;
        if (double && buf & 1) buf++;
        readAsmConstArgsArray.push(double ? HEAPF64[buf++ >> 1] : HEAP32[buf]);
        ++buf;
      }
      return readAsmConstArgsArray;
    }
    function _emscripten_asm_const_int(code, sigPtr, argbuf) {
      var args = readAsmConstArgs(sigPtr, argbuf);
      return ASM_CONSTS[code].apply(null, args);
    }
    function _emscripten_conditional_set_current_thread_status(
      expectedStatus,
      newStatus
    ) {}
    function _emscripten_memcpy_big(dest, src, num) {
      HEAPU8.copyWithin(dest, src, src + num);
    }
    function _emscripten_proxy_to_main_thread_js(index, sync) {
      var numCallArgs = arguments.length - 2;
      var stack = stackSave();
      var serializedNumCallArgs = numCallArgs;
      var args = stackAlloc(serializedNumCallArgs * 8);
      var b = args >> 3;
      for (var i = 0; i < numCallArgs; i++) {
        var arg = arguments[2 + i];
        HEAPF64[b + i] = arg;
      }
      var ret = _emscripten_run_in_main_runtime_thread_js(
        index,
        serializedNumCallArgs,
        args,
        sync
      );
      stackRestore(stack);
      return ret;
    }
    var _emscripten_receive_on_main_thread_js_callArgs = [];
    function _emscripten_receive_on_main_thread_js(index, numCallArgs, args) {
      _emscripten_receive_on_main_thread_js_callArgs.length = numCallArgs;
      var b = args >> 3;
      for (var i = 0; i < numCallArgs; i++) {
        _emscripten_receive_on_main_thread_js_callArgs[i] = HEAPF64[b + i];
      }
      var isEmAsmConst = index < 0;
      var func = !isEmAsmConst
        ? proxiedFunctionTable[index]
        : ASM_CONSTS[-index - 1];
      return func.apply(null, _emscripten_receive_on_main_thread_js_callArgs);
    }
    function abortOnCannotGrowMemory(requestedSize) {
      abort('OOM');
    }
    function _emscripten_resize_heap(requestedSize) {
      var oldSize = HEAPU8.length;
      requestedSize = requestedSize >>> 0;
      abortOnCannotGrowMemory(requestedSize);
    }
    var JSEvents = {
      inEventHandler: 0,
      removeAllEventListeners: function () {
        for (var i = JSEvents.eventHandlers.length - 1; i >= 0; --i) {
          JSEvents._removeHandler(i);
        }
        JSEvents.eventHandlers = [];
        JSEvents.deferredCalls = [];
      },
      registerRemoveEventListeners: function () {
        if (!JSEvents.removeEventListenersRegistered) {
          __ATEXIT__.push(JSEvents.removeAllEventListeners);
          JSEvents.removeEventListenersRegistered = true;
        }
      },
      deferredCalls: [],
      deferCall: function (targetFunction, precedence, argsList) {
        function arraysHaveEqualContent(arrA, arrB) {
          if (arrA.length != arrB.length) return false;
          for (var i in arrA) {
            if (arrA[i] != arrB[i]) return false;
          }
          return true;
        }
        for (var i in JSEvents.deferredCalls) {
          var call = JSEvents.deferredCalls[i];
          if (
            call.targetFunction == targetFunction &&
            arraysHaveEqualContent(call.argsList, argsList)
          ) {
            return;
          }
        }
        JSEvents.deferredCalls.push({
          targetFunction: targetFunction,
          precedence: precedence,
          argsList: argsList
        });
        JSEvents.deferredCalls.sort(function (x, y) {
          return x.precedence < y.precedence;
        });
      },
      removeDeferredCalls: function (targetFunction) {
        for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
          if (JSEvents.deferredCalls[i].targetFunction == targetFunction) {
            JSEvents.deferredCalls.splice(i, 1);
            --i;
          }
        }
      },
      canPerformEventHandlerRequests: function () {
        return (
          JSEvents.inEventHandler &&
          JSEvents.currentEventHandler.allowsDeferredCalls
        );
      },
      runDeferredCalls: function () {
        if (!JSEvents.canPerformEventHandlerRequests()) {
          return;
        }
        for (var i = 0; i < JSEvents.deferredCalls.length; ++i) {
          var call = JSEvents.deferredCalls[i];
          JSEvents.deferredCalls.splice(i, 1);
          --i;
          call.targetFunction.apply(null, call.argsList);
        }
      },
      eventHandlers: [],
      removeAllHandlersOnTarget: function (target, eventTypeString) {
        for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
          if (
            JSEvents.eventHandlers[i].target == target &&
            (!eventTypeString ||
              eventTypeString == JSEvents.eventHandlers[i].eventTypeString)
          ) {
            JSEvents._removeHandler(i--);
          }
        }
      },
      _removeHandler: function (i) {
        var h = JSEvents.eventHandlers[i];
        h.target.removeEventListener(
          h.eventTypeString,
          h.eventListenerFunc,
          h.useCapture
        );
        JSEvents.eventHandlers.splice(i, 1);
      },
      registerOrRemoveHandler: function (eventHandler) {
        var jsEventHandler = function jsEventHandler(event) {
          ++JSEvents.inEventHandler;
          JSEvents.currentEventHandler = eventHandler;
          JSEvents.runDeferredCalls();
          eventHandler.handlerFunc(event);
          JSEvents.runDeferredCalls();
          --JSEvents.inEventHandler;
        };
        if (eventHandler.callbackfunc) {
          eventHandler.eventListenerFunc = jsEventHandler;
          eventHandler.target.addEventListener(
            eventHandler.eventTypeString,
            jsEventHandler,
            eventHandler.useCapture
          );
          JSEvents.eventHandlers.push(eventHandler);
          JSEvents.registerRemoveEventListeners();
        } else {
          for (var i = 0; i < JSEvents.eventHandlers.length; ++i) {
            if (
              JSEvents.eventHandlers[i].target == eventHandler.target &&
              JSEvents.eventHandlers[i].eventTypeString ==
                eventHandler.eventTypeString
            ) {
              JSEvents._removeHandler(i--);
            }
          }
        }
      },
      queueEventHandlerOnThread_iiii: function (
        targetThread,
        eventHandlerFunc,
        eventTypeId,
        eventData,
        userData
      ) {
        var stackTop = stackSave();
        var varargs = stackAlloc(12);
        HEAP32[varargs >> 2] = eventTypeId;
        HEAP32[(varargs + 4) >> 2] = eventData;
        HEAP32[(varargs + 8) >> 2] = userData;
        __emscripten_call_on_thread(
          0,
          targetThread,
          637534208,
          eventHandlerFunc,
          eventData,
          varargs
        );
        stackRestore(stackTop);
      },
      getTargetThreadForEventCallback: function (targetThread) {
        switch (targetThread) {
          case 1:
            return 0;
          case 2:
            return PThread.currentProxiedOperationCallerThread;
          default:
            return targetThread;
        }
      },
      getNodeNameForTarget: function (target) {
        if (!target) return '';
        if (target == window) return '#window';
        if (target == screen) return '#screen';
        return target && target.nodeName ? target.nodeName : '';
      },
      fullscreenEnabled: function () {
        return document.fullscreenEnabled || document.webkitFullscreenEnabled;
      }
    };
    function stringToNewUTF8(jsString) {
      var length = lengthBytesUTF8(jsString) + 1;
      var cString = _malloc(length);
      stringToUTF8(jsString, cString, length);
      return cString;
    }
    function _emscripten_set_offscreencanvas_size_on_target_thread_js(
      targetThread,
      targetCanvas,
      width,
      height
    ) {
      var stackTop = stackSave();
      var varargs = stackAlloc(12);
      var targetCanvasPtr = 0;
      if (targetCanvas) {
        targetCanvasPtr = stringToNewUTF8(targetCanvas);
      }
      HEAP32[varargs >> 2] = targetCanvasPtr;
      HEAP32[(varargs + 4) >> 2] = width;
      HEAP32[(varargs + 8) >> 2] = height;
      __emscripten_call_on_thread(
        0,
        targetThread,
        657457152,
        0,
        targetCanvasPtr,
        varargs
      );
      stackRestore(stackTop);
    }
    function _emscripten_set_offscreencanvas_size_on_target_thread(
      targetThread,
      targetCanvas,
      width,
      height
    ) {
      targetCanvas = targetCanvas ? UTF8ToString(targetCanvas) : '';
      _emscripten_set_offscreencanvas_size_on_target_thread_js(
        targetThread,
        targetCanvas,
        width,
        height
      );
    }
    function maybeCStringToJsString(cString) {
      return cString > 2 ? UTF8ToString(cString) : cString;
    }
    var specialHTMLTargets = [
      0,
      typeof document !== 'undefined' ? document : 0,
      typeof window !== 'undefined' ? window : 0
    ];
    function findEventTarget(target) {
      target = maybeCStringToJsString(target);
      var domElement =
        specialHTMLTargets[target] ||
        (typeof document !== 'undefined'
          ? document.querySelector(target)
          : undefined);
      return domElement;
    }
    function findCanvasEventTarget(target) {
      return findEventTarget(target);
    }
    function _emscripten_set_canvas_element_size_calling_thread(
      target,
      width,
      height
    ) {
      var canvas = findCanvasEventTarget(target);
      if (!canvas) return -4;
      if (canvas.canvasSharedPtr) {
        HEAP32[canvas.canvasSharedPtr >> 2] = width;
        HEAP32[(canvas.canvasSharedPtr + 4) >> 2] = height;
      }
      if (canvas.offscreenCanvas || !canvas.controlTransferredOffscreen) {
        if (canvas.offscreenCanvas) canvas = canvas.offscreenCanvas;
        var autoResizeViewport = false;
        if (canvas.GLctxObject && canvas.GLctxObject.GLctx) {
          var prevViewport = canvas.GLctxObject.GLctx.getParameter(2978);
          autoResizeViewport =
            prevViewport[0] === 0 &&
            prevViewport[1] === 0 &&
            prevViewport[2] === canvas.width &&
            prevViewport[3] === canvas.height;
        }
        canvas.width = width;
        canvas.height = height;
        if (autoResizeViewport) {
          canvas.GLctxObject.GLctx.viewport(0, 0, width, height);
        }
      } else if (canvas.canvasSharedPtr) {
        var targetThread = HEAP32[(canvas.canvasSharedPtr + 8) >> 2];
        _emscripten_set_offscreencanvas_size_on_target_thread(
          targetThread,
          target,
          width,
          height
        );
        return 1;
      } else {
        return -4;
      }
      return 0;
    }
    function _emscripten_set_canvas_element_size_main_thread(
      target,
      width,
      height
    ) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          45,
          1,
          target,
          width,
          height
        );
      return _emscripten_set_canvas_element_size_calling_thread(
        target,
        width,
        height
      );
    }
    function _emscripten_set_canvas_element_size(target, width, height) {
      var canvas = findCanvasEventTarget(target);
      if (canvas) {
        return _emscripten_set_canvas_element_size_calling_thread(
          target,
          width,
          height
        );
      } else {
        return _emscripten_set_canvas_element_size_main_thread(
          target,
          width,
          height
        );
      }
    }
    function _emscripten_set_current_thread_status(newStatus) {}
    function _emscripten_set_timeout(cb, msecs, userData) {
      runtimeKeepalivePush();
      return setTimeout(function () {
        runtimeKeepalivePop();
        callUserCallback(function () {
          wasmTable.get(cb)(userData);
        });
      }, msecs);
    }
    function _emscripten_unwind_to_js_event_loop() {
      throw 'unwind';
    }
    function __webgl_enable_ANGLE_instanced_arrays(ctx) {
      var ext = ctx.getExtension('ANGLE_instanced_arrays');
      if (ext) {
        ctx['vertexAttribDivisor'] = function (index, divisor) {
          ext['vertexAttribDivisorANGLE'](index, divisor);
        };
        ctx['drawArraysInstanced'] = function (mode, first, count, primcount) {
          ext['drawArraysInstancedANGLE'](mode, first, count, primcount);
        };
        ctx['drawElementsInstanced'] = function (
          mode,
          count,
          type,
          indices,
          primcount
        ) {
          ext['drawElementsInstancedANGLE'](
            mode,
            count,
            type,
            indices,
            primcount
          );
        };
        return 1;
      }
    }
    function __webgl_enable_OES_vertex_array_object(ctx) {
      var ext = ctx.getExtension('OES_vertex_array_object');
      if (ext) {
        ctx['createVertexArray'] = function () {
          return ext['createVertexArrayOES']();
        };
        ctx['deleteVertexArray'] = function (vao) {
          ext['deleteVertexArrayOES'](vao);
        };
        ctx['bindVertexArray'] = function (vao) {
          ext['bindVertexArrayOES'](vao);
        };
        ctx['isVertexArray'] = function (vao) {
          return ext['isVertexArrayOES'](vao);
        };
        return 1;
      }
    }
    function __webgl_enable_WEBGL_draw_buffers(ctx) {
      var ext = ctx.getExtension('WEBGL_draw_buffers');
      if (ext) {
        ctx['drawBuffers'] = function (n, bufs) {
          ext['drawBuffersWEBGL'](n, bufs);
        };
        return 1;
      }
    }
    function __webgl_enable_WEBGL_multi_draw(ctx) {
      return !!(ctx.multiDrawWebgl = ctx.getExtension('WEBGL_multi_draw'));
    }
    var GL = {
      counter: 1,
      buffers: [],
      programs: [],
      framebuffers: [],
      renderbuffers: [],
      textures: [],
      shaders: [],
      vaos: [],
      contexts: {},
      offscreenCanvases: {},
      queries: [],
      stringCache: {},
      unpackAlignment: 4,
      recordError: function recordError(errorCode) {
        if (!GL.lastError) {
          GL.lastError = errorCode;
        }
      },
      getNewId: function (table) {
        var ret = GL.counter++;
        for (var i = table.length; i < ret; i++) {
          table[i] = null;
        }
        return ret;
      },
      getSource: function (shader, count, string, length) {
        var source = '';
        for (var i = 0; i < count; ++i) {
          var len = length ? HEAP32[(length + i * 4) >> 2] : -1;
          source += UTF8ToString(
            HEAP32[(string + i * 4) >> 2],
            len < 0 ? undefined : len
          );
        }
        return source;
      },
      createContext: function (canvas, webGLContextAttributes) {
        if (!canvas.getContextSafariWebGL2Fixed) {
          canvas.getContextSafariWebGL2Fixed = canvas.getContext;
          canvas.getContext = function (ver, attrs) {
            var gl = canvas.getContextSafariWebGL2Fixed(ver, attrs);
            return (ver == 'webgl') == gl instanceof WebGLRenderingContext
              ? gl
              : null;
          };
        }
        var ctx = canvas.getContext('webgl', webGLContextAttributes);
        if (!ctx) return 0;
        var handle = GL.registerContext(ctx, webGLContextAttributes);
        return handle;
      },
      registerContext: function (ctx, webGLContextAttributes) {
        var handle = _malloc(8);
        HEAP32[(handle + 4) >> 2] = _pthread_self();
        var context = {
          handle: handle,
          attributes: webGLContextAttributes,
          version: webGLContextAttributes.majorVersion,
          GLctx: ctx
        };
        if (ctx.canvas) ctx.canvas.GLctxObject = context;
        GL.contexts[handle] = context;
        if (
          typeof webGLContextAttributes.enableExtensionsByDefault ===
            'undefined' ||
          webGLContextAttributes.enableExtensionsByDefault
        ) {
          GL.initExtensions(context);
        }
        return handle;
      },
      makeContextCurrent: function (contextHandle) {
        GL.currentContext = GL.contexts[contextHandle];
        Module.ctx = GLctx = GL.currentContext && GL.currentContext.GLctx;
        return !(contextHandle && !GLctx);
      },
      getContext: function (contextHandle) {
        return GL.contexts[contextHandle];
      },
      deleteContext: function (contextHandle) {
        if (GL.currentContext === GL.contexts[contextHandle])
          GL.currentContext = null;
        if (typeof JSEvents === 'object')
          JSEvents.removeAllHandlersOnTarget(
            GL.contexts[contextHandle].GLctx.canvas
          );
        if (
          GL.contexts[contextHandle] &&
          GL.contexts[contextHandle].GLctx.canvas
        )
          GL.contexts[contextHandle].GLctx.canvas.GLctxObject = undefined;
        _free(GL.contexts[contextHandle].handle);
        GL.contexts[contextHandle] = null;
      },
      initExtensions: function (context) {
        if (!context) context = GL.currentContext;
        if (context.initExtensionsDone) return;
        context.initExtensionsDone = true;
        var GLctx = context.GLctx;
        __webgl_enable_ANGLE_instanced_arrays(GLctx);
        __webgl_enable_OES_vertex_array_object(GLctx);
        __webgl_enable_WEBGL_draw_buffers(GLctx);
        {
          GLctx.disjointTimerQueryExt = GLctx.getExtension(
            'EXT_disjoint_timer_query'
          );
        }
        __webgl_enable_WEBGL_multi_draw(GLctx);
        var exts = GLctx.getSupportedExtensions() || [];
        exts.forEach(function (ext) {
          if (!ext.includes('lose_context') && !ext.includes('debug')) {
            GLctx.getExtension(ext);
          }
        });
      }
    };
    var __emscripten_webgl_power_preferences = [
      'default',
      'low-power',
      'high-performance'
    ];
    function _emscripten_webgl_do_create_context(target, attributes) {
      var a = attributes >> 2;
      var powerPreference = HEAP32[a + (24 >> 2)];
      var contextAttributes = {
        alpha: !!HEAP32[a + (0 >> 2)],
        depth: !!HEAP32[a + (4 >> 2)],
        stencil: !!HEAP32[a + (8 >> 2)],
        antialias: !!HEAP32[a + (12 >> 2)],
        premultipliedAlpha: !!HEAP32[a + (16 >> 2)],
        preserveDrawingBuffer: !!HEAP32[a + (20 >> 2)],
        powerPreference: __emscripten_webgl_power_preferences[powerPreference],
        failIfMajorPerformanceCaveat: !!HEAP32[a + (28 >> 2)],
        majorVersion: HEAP32[a + (32 >> 2)],
        minorVersion: HEAP32[a + (36 >> 2)],
        enableExtensionsByDefault: HEAP32[a + (40 >> 2)],
        explicitSwapControl: HEAP32[a + (44 >> 2)],
        proxyContextToMainThread: HEAP32[a + (48 >> 2)],
        renderViaOffscreenBackBuffer: HEAP32[a + (52 >> 2)]
      };
      var canvas = findCanvasEventTarget(target);
      if (!canvas) {
        return 0;
      }
      if (contextAttributes.explicitSwapControl) {
        return 0;
      }
      var contextHandle = GL.createContext(canvas, contextAttributes);
      return contextHandle;
    }
    function _emscripten_webgl_create_context(a0, a1) {
      return _emscripten_webgl_do_create_context(a0, a1);
    }
    var SYSCALLS = {
      mappings: {},
      buffers: [null, [], []],
      printChar: function (stream, curr) {
        var buffer = SYSCALLS.buffers[stream];
        if (curr === 0 || curr === 10) {
          (stream === 1 ? out : err)(UTF8ArrayToString(buffer, 0));
          buffer.length = 0;
        } else {
          buffer.push(curr);
        }
      },
      varargs: undefined,
      get: function () {
        SYSCALLS.varargs += 4;
        var ret = HEAP32[(SYSCALLS.varargs - 4) >> 2];
        return ret;
      },
      getStr: function (ptr) {
        var ret = UTF8ToString(ptr);
        return ret;
      },
      get64: function (low, high) {
        return low;
      }
    };
    function _fd_write(fd, iov, iovcnt, pnum) {
      if (ENVIRONMENT_IS_PTHREAD)
        return _emscripten_proxy_to_main_thread_js(
          46,
          1,
          fd,
          iov,
          iovcnt,
          pnum
        );
      var num = 0;
      for (var i = 0; i < iovcnt; i++) {
        var ptr = HEAP32[(iov + i * 8) >> 2];
        var len = HEAP32[(iov + (i * 8 + 4)) >> 2];
        for (var j = 0; j < len; j++) {
          SYSCALLS.printChar(fd, HEAPU8[ptr + j]);
        }
        num += len;
      }
      HEAP32[pnum >> 2] = num;
      return 0;
    }
    function _setTempRet0(val) {
      setTempRet0(val);
    }
    if (!ENVIRONMENT_IS_PTHREAD) PThread.initMainThreadBlock();
    InternalError = Module['InternalError'] = extendError(
      Error,
      'InternalError'
    );
    embind_init_charCodes();
    BindingError = Module['BindingError'] = extendError(Error, 'BindingError');
    init_emval();
    UnboundTypeError = Module['UnboundTypeError'] = extendError(
      Error,
      'UnboundTypeError'
    );
    Module['requestFullscreen'] = function Module_requestFullscreen(
      lockPointer,
      resizeCanvas
    ) {
      Browser.requestFullscreen(lockPointer, resizeCanvas);
    };
    Module['requestAnimationFrame'] = function Module_requestAnimationFrame(
      func
    ) {
      Browser.requestAnimationFrame(func);
    };
    Module['setCanvasSize'] = function Module_setCanvasSize(
      width,
      height,
      noUpdates
    ) {
      Browser.setCanvasSize(width, height, noUpdates);
    };
    Module['pauseMainLoop'] = function Module_pauseMainLoop() {
      Browser.mainLoop.pause();
    };
    Module['resumeMainLoop'] = function Module_resumeMainLoop() {
      Browser.mainLoop.resume();
    };
    Module['getUserMedia'] = function Module_getUserMedia() {
      Browser.getUserMedia();
    };
    Module['createContext'] = function Module_createContext(
      canvas,
      useWebGL,
      setInModule,
      webGLContextAttributes
    ) {
      return Browser.createContext(
        canvas,
        useWebGL,
        setInModule,
        webGLContextAttributes
      );
    };
    var GLctx;
    var proxiedFunctionTable = [
      null,
      _CaptureDataCB,
      _DecodeDataCB,
      _EncodeDataCB,
      _ResampleDataCB,
      _atexit,
      _alBufferData,
      _alDeleteBuffers,
      _alSourcei,
      _alDeleteSources,
      _alGenBuffers,
      _alGenSources,
      _alGetEnumValue,
      _alGetError,
      _alGetSourcef,
      _alGetSourcei,
      _alIsSource,
      _alListenerfv,
      _alSourcePlay,
      _alSourceQueueBuffers,
      _alSourceStop,
      _alSourceUnqueueBuffers,
      _alSourcef,
      _alSourcefv,
      _alcCaptureCloseDevice,
      _alcCaptureOpenDevice,
      _alcCaptureSamples,
      _alcCaptureStart,
      _alcCaptureStop,
      _alcCloseDevice,
      _alcCreateContext,
      _alcDestroyContext,
      _alcGetContextsDevice,
      _alcGetCurrentContext,
      _alcGetEnumValue,
      _alcGetError,
      _alcGetIntegerv,
      _alcGetString,
      _alcIsExtensionPresent,
      _alcMakeContextCurrent,
      _alcOpenDevice,
      _emscripten_alcDevicePauseSOFT,
      _emscripten_alcDeviceResumeSOFT,
      _emscripten_alcGetStringiSOFT,
      _emscripten_alcResetDeviceSOFT,
      _emscripten_set_canvas_element_size_main_thread,
      _fd_write
    ];
    function intArrayFromString(stringy, dontAddNull, length) {
      var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
      var u8array = new Array(len);
      var numBytesWritten = stringToUTF8Array(
        stringy,
        u8array,
        0,
        u8array.length
      );
      if (dontAddNull) u8array.length = numBytesWritten;
      return u8array;
    }
    var asmLibraryArg = {
      pa: _CaptureDataCB,
      ma: _DecodeDataCB,
      na: _EncodeDataCB,
      oa: _ResampleDataCB,
      c: ___assert_fail,
      L: ___cxa_allocate_exception,
      Fa: ___cxa_thread_atexit,
      Da: ___cxa_throw,
      va: ___emscripten_init_main_thread_js,
      K: ___pthread_create_js,
      ua: ___pthread_detached_exit,
      Ca: ___pthread_exit_run_handlers,
      la: ___pthread_join_js,
      P: __embind_finalize_value_object,
      M: __embind_register_bigint,
      Aa: __embind_register_bool,
      ka: __embind_register_emval,
      t: __embind_register_float,
      O: __embind_register_function,
      d: __embind_register_integer,
      b: __embind_register_memory_view,
      I: __embind_register_std_string,
      s: __embind_register_std_wstring,
      Q: __embind_register_value_object,
      f: __embind_register_value_object_field,
      Ea: __embind_register_void,
      Ba: __emscripten_notify_thread_queue,
      p: _alBufferData,
      F: _alDeleteBuffers,
      G: _alDeleteSources,
      C: _alGenBuffers,
      B: _alGenSources,
      S: _alGetEnumValue,
      z: _alGetError,
      v: _alGetSourcef,
      g: _alGetSourcei,
      ga: _alIsSource,
      k: _alListenerfv,
      w: _alSourcePlay,
      o: _alSourceQueueBuffers,
      m: _alSourceStop,
      h: _alSourceUnqueueBuffers,
      l: _alSourcef,
      q: _alSourcefv,
      A: _alSourcei,
      _: _alcCaptureCloseDevice,
      $: _alcCaptureOpenDevice,
      X: _alcCaptureSamples,
      Z: _alcCaptureStart,
      Y: _alcCaptureStop,
      ja: _alcCloseDevice,
      E: _alcCreateContext,
      ia: _alcDestroyContext,
      ca: _alcGetContextsDevice,
      r: _alcGetCurrentContext,
      aa: _alcGetEnumValue,
      ba: _alcGetError,
      fa: _alcGetIntegerv,
      y: _alcGetString,
      ha: _alcIsExtensionPresent,
      D: _alcMakeContextCurrent,
      x: _alcOpenDevice,
      ea: _alcProcessContext,
      da: _alcSuspendContext,
      R: _clock,
      W: _emscripten_alcDevicePauseSOFT,
      V: _emscripten_alcDeviceResumeSOFT,
      U: _emscripten_alcGetStringiSOFT,
      T: _emscripten_alcResetDeviceSOFT,
      u: _emscripten_asm_const_int,
      n: _emscripten_conditional_set_current_thread_status,
      j: _emscripten_futex_wait,
      i: _emscripten_futex_wake,
      e: _emscripten_get_now,
      qa: _emscripten_memcpy_big,
      xa: _emscripten_receive_on_main_thread_js,
      ra: _emscripten_resize_heap,
      ya: _emscripten_set_canvas_element_size,
      J: _emscripten_set_current_thread_status,
      wa: _emscripten_set_timeout,
      sa: _emscripten_unwind_to_js_event_loop,
      za: _emscripten_webgl_create_context,
      ta: _exit,
      H: _fd_write,
      a: wasmMemory || Module['wasmMemory'],
      N: _setTempRet0
    };
    var asm = createWasm();
    var ___wasm_call_ctors = (Module['___wasm_call_ctors'] = function () {
      return (___wasm_call_ctors = Module['___wasm_call_ctors'] =
        Module['asm']['Ga']).apply(null, arguments);
    });
    var _CaptureDataCallBack = (Module['_CaptureDataCallBack'] = function () {
      return (_CaptureDataCallBack = Module['_CaptureDataCallBack'] =
        Module['asm']['Ha']).apply(null, arguments);
    });
    var _ResampleDataCallBack = (Module['_ResampleDataCallBack'] = function () {
      return (_ResampleDataCallBack = Module['_ResampleDataCallBack'] =
        Module['asm']['Ia']).apply(null, arguments);
    });
    var _EncodeDataCallBack = (Module['_EncodeDataCallBack'] = function () {
      return (_EncodeDataCallBack = Module['_EncodeDataCallBack'] =
        Module['asm']['Ja']).apply(null, arguments);
    });
    var _DecodeDataCallBack = (Module['_DecodeDataCallBack'] = function () {
      return (_DecodeDataCallBack = Module['_DecodeDataCallBack'] =
        Module['asm']['Ka']).apply(null, arguments);
    });
    var _JSAUDIOCOM_LoadLibrary = (Module['_JSAUDIOCOM_LoadLibrary'] =
      function () {
        return (_JSAUDIOCOM_LoadLibrary = Module['_JSAUDIOCOM_LoadLibrary'] =
          Module['asm']['La']).apply(null, arguments);
      });
    var _JSAUDIOCOM_GetSoundCardNum = (Module['_JSAUDIOCOM_GetSoundCardNum'] =
      function () {
        return (_JSAUDIOCOM_GetSoundCardNum = Module[
          '_JSAUDIOCOM_GetSoundCardNum'
        ] =
          Module['asm']['Ma']).apply(null, arguments);
      });
    var _JSAUDIOCOM_GetOneSoundCardInfo = (Module[
      '_JSAUDIOCOM_GetOneSoundCardInfo'
    ] = function () {
      return (_JSAUDIOCOM_GetOneSoundCardInfo = Module[
        '_JSAUDIOCOM_GetOneSoundCardInfo'
      ] =
        Module['asm']['Na']).apply(null, arguments);
    });
    var _JSAUDIOCOM_GetCaptureDeviceNum = (Module[
      '_JSAUDIOCOM_GetCaptureDeviceNum'
    ] = function () {
      return (_JSAUDIOCOM_GetCaptureDeviceNum = Module[
        '_JSAUDIOCOM_GetCaptureDeviceNum'
      ] =
        Module['asm']['Oa']).apply(null, arguments);
    });
    var _JSAUDIOCOM_GetOneCaptureDeviceName = (Module[
      '_JSAUDIOCOM_GetOneCaptureDeviceName'
    ] = function () {
      return (_JSAUDIOCOM_GetOneCaptureDeviceName = Module[
        '_JSAUDIOCOM_GetOneCaptureDeviceName'
      ] =
        Module['asm']['Pa']).apply(null, arguments);
    });
    var _JSAUDIOCOM_CreateCaptureHandle = (Module[
      '_JSAUDIOCOM_CreateCaptureHandle'
    ] = function () {
      return (_JSAUDIOCOM_CreateCaptureHandle = Module[
        '_JSAUDIOCOM_CreateCaptureHandle'
      ] =
        Module['asm']['Qa']).apply(null, arguments);
    });
    var _JSAUDIOCOM_RegisterCaptureDataCallBack = (Module[
      '_JSAUDIOCOM_RegisterCaptureDataCallBack'
    ] = function () {
      return (_JSAUDIOCOM_RegisterCaptureDataCallBack = Module[
        '_JSAUDIOCOM_RegisterCaptureDataCallBack'
      ] =
        Module['asm']['Ra']).apply(null, arguments);
    });
    var _JSAUDIOCOM_RegisterEncodeDataCallBack0 = (Module[
      '_JSAUDIOCOM_RegisterEncodeDataCallBack0'
    ] = function () {
      return (_JSAUDIOCOM_RegisterEncodeDataCallBack0 = Module[
        '_JSAUDIOCOM_RegisterEncodeDataCallBack0'
      ] =
        Module['asm']['Sa']).apply(null, arguments);
    });
    var _JSAUDIOCOM_RegisterResampleDataCallBack = (Module[
      '_JSAUDIOCOM_RegisterResampleDataCallBack'
    ] = function () {
      return (_JSAUDIOCOM_RegisterResampleDataCallBack = Module[
        '_JSAUDIOCOM_RegisterResampleDataCallBack'
      ] =
        Module['asm']['Ta']).apply(null, arguments);
    });
    var _JSAUDIOCOM_StartCapture = (Module['_JSAUDIOCOM_StartCapture'] =
      function () {
        return (_JSAUDIOCOM_StartCapture = Module['_JSAUDIOCOM_StartCapture'] =
          Module['asm']['Ua']).apply(null, arguments);
      });
    var _JSAUDIOCOM_StopCapture = (Module['_JSAUDIOCOM_StopCapture'] =
      function () {
        return (_JSAUDIOCOM_StopCapture = Module['_JSAUDIOCOM_StopCapture'] =
          Module['asm']['Va']).apply(null, arguments);
      });
    var _JSAUDIOCOM_ReleaseCaptureHandle = (Module[
      '_JSAUDIOCOM_ReleaseCaptureHandle'
    ] = function () {
      return (_JSAUDIOCOM_ReleaseCaptureHandle = Module[
        '_JSAUDIOCOM_ReleaseCaptureHandle'
      ] =
        Module['asm']['Wa']).apply(null, arguments);
    });
    var _JSAUDIOCOM_SetCaptureStatus = (Module['_JSAUDIOCOM_SetCaptureStatus'] =
      function () {
        return (_JSAUDIOCOM_SetCaptureStatus = Module[
          '_JSAUDIOCOM_SetCaptureStatus'
        ] =
          Module['asm']['Xa']).apply(null, arguments);
      });
    var _JSAUDIOCOM_CreateEncodeHandle = (Module[
      '_JSAUDIOCOM_CreateEncodeHandle'
    ] = function () {
      return (_JSAUDIOCOM_CreateEncodeHandle = Module[
        '_JSAUDIOCOM_CreateEncodeHandle'
      ] =
        Module['asm']['Ya']).apply(null, arguments);
    });
    var _JSAUDIOCOM_RegisterEncodeDataCallBack = (Module[
      '_JSAUDIOCOM_RegisterEncodeDataCallBack'
    ] = function () {
      return (_JSAUDIOCOM_RegisterEncodeDataCallBack = Module[
        '_JSAUDIOCOM_RegisterEncodeDataCallBack'
      ] =
        Module['asm']['Za']).apply(null, arguments);
    });
    var _JSAUDIOCOM_StartEncode = (Module['_JSAUDIOCOM_StartEncode'] =
      function () {
        return (_JSAUDIOCOM_StartEncode = Module['_JSAUDIOCOM_StartEncode'] =
          Module['asm']['_a']).apply(null, arguments);
      });
    var _JSAUDIOCOM_InputEncodeData = (Module['_JSAUDIOCOM_InputEncodeData'] =
      function () {
        return (_JSAUDIOCOM_InputEncodeData = Module[
          '_JSAUDIOCOM_InputEncodeData'
        ] =
          Module['asm']['$a']).apply(null, arguments);
      });
    var _JSAUDIOCOM_StopEncode = (Module['_JSAUDIOCOM_StopEncode'] =
      function () {
        return (_JSAUDIOCOM_StopEncode = Module['_JSAUDIOCOM_StopEncode'] =
          Module['asm']['ab']).apply(null, arguments);
      });
    var _JSAUDIOCOM_ReleaseEncodeHandle = (Module[
      '_JSAUDIOCOM_ReleaseEncodeHandle'
    ] = function () {
      return (_JSAUDIOCOM_ReleaseEncodeHandle = Module[
        '_JSAUDIOCOM_ReleaseEncodeHandle'
      ] =
        Module['asm']['bb']).apply(null, arguments);
    });
    var _JSAUDIOCOM_GetPlayDeviceNum = (Module['_JSAUDIOCOM_GetPlayDeviceNum'] =
      function () {
        return (_JSAUDIOCOM_GetPlayDeviceNum = Module[
          '_JSAUDIOCOM_GetPlayDeviceNum'
        ] =
          Module['asm']['cb']).apply(null, arguments);
      });
    var _JSAUDIOCOM_GetOnePlayDeviceName = (Module[
      '_JSAUDIOCOM_GetOnePlayDeviceName'
    ] = function () {
      return (_JSAUDIOCOM_GetOnePlayDeviceName = Module[
        '_JSAUDIOCOM_GetOnePlayDeviceName'
      ] =
        Module['asm']['db']).apply(null, arguments);
    });
    var _JSAUDIOCOM_CreatePlayHandle = (Module['_JSAUDIOCOM_CreatePlayHandle'] =
      function () {
        return (_JSAUDIOCOM_CreatePlayHandle = Module[
          '_JSAUDIOCOM_CreatePlayHandle'
        ] =
          Module['asm']['eb']).apply(null, arguments);
      });
    var _JSAUDIOCOM_OpenStream = (Module['_JSAUDIOCOM_OpenStream'] =
      function () {
        return (_JSAUDIOCOM_OpenStream = Module['_JSAUDIOCOM_OpenStream'] =
          Module['asm']['fb']).apply(null, arguments);
      });
    var _JSAUDIOCOM_RegisterDecodeDataCallBack = (Module[
      '_JSAUDIOCOM_RegisterDecodeDataCallBack'
    ] = function () {
      return (_JSAUDIOCOM_RegisterDecodeDataCallBack = Module[
        '_JSAUDIOCOM_RegisterDecodeDataCallBack'
      ] =
        Module['asm']['gb']).apply(null, arguments);
    });
    var _JSAUDIOCOM_StartPlay = (Module['_JSAUDIOCOM_StartPlay'] = function () {
      return (_JSAUDIOCOM_StartPlay = Module['_JSAUDIOCOM_StartPlay'] =
        Module['asm']['hb']).apply(null, arguments);
    });
    var _JSAUDIOCOM_SetPlayStatus = (Module['_JSAUDIOCOM_SetPlayStatus'] =
      function () {
        return (_JSAUDIOCOM_SetPlayStatus = Module[
          '_JSAUDIOCOM_SetPlayStatus'
        ] =
          Module['asm']['ib']).apply(null, arguments);
      });
    var _JSAUDIOCOM_InputStreamData = (Module['_JSAUDIOCOM_InputStreamData'] =
      function () {
        return (_JSAUDIOCOM_InputStreamData = Module[
          '_JSAUDIOCOM_InputStreamData'
        ] =
          Module['asm']['jb']).apply(null, arguments);
      });
    var _JSAUDIOCOM_StopPlay = (Module['_JSAUDIOCOM_StopPlay'] = function () {
      return (_JSAUDIOCOM_StopPlay = Module['_JSAUDIOCOM_StopPlay'] =
        Module['asm']['kb']).apply(null, arguments);
    });
    var _JSAUDIOCOM_ReleasePlayHandle = (Module[
      '_JSAUDIOCOM_ReleasePlayHandle'
    ] = function () {
      return (_JSAUDIOCOM_ReleasePlayHandle = Module[
        '_JSAUDIOCOM_ReleasePlayHandle'
      ] =
        Module['asm']['lb']).apply(null, arguments);
    });
    var _JSAUDIOCOM_SetVolume = (Module['_JSAUDIOCOM_SetVolume'] = function () {
      return (_JSAUDIOCOM_SetVolume = Module['_JSAUDIOCOM_SetVolume'] =
        Module['asm']['mb']).apply(null, arguments);
    });
    var _JSAUDIOCOM_GetVolume = (Module['_JSAUDIOCOM_GetVolume'] = function () {
      return (_JSAUDIOCOM_GetVolume = Module['_JSAUDIOCOM_GetVolume'] =
        Module['asm']['nb']).apply(null, arguments);
    });
    var _JSAUDIOCOM_GetLastError = (Module['_JSAUDIOCOM_GetLastError'] =
      function () {
        return (_JSAUDIOCOM_GetLastError = Module['_JSAUDIOCOM_GetLastError'] =
          Module['asm']['ob']).apply(null, arguments);
      });
    var _JSAUDIOCOM_GetSDKVersion = (Module['_JSAUDIOCOM_GetSDKVersion'] =
      function () {
        return (_JSAUDIOCOM_GetSDKVersion = Module[
          '_JSAUDIOCOM_GetSDKVersion'
        ] =
          Module['asm']['pb']).apply(null, arguments);
      });
    var _JSAUDIOCOM_GetBuildDate = (Module['_JSAUDIOCOM_GetBuildDate'] =
      function () {
        return (_JSAUDIOCOM_GetBuildDate = Module['_JSAUDIOCOM_GetBuildDate'] =
          Module['asm']['qb']).apply(null, arguments);
      });
    var _JSAUDIOCOM_GetPlayBufferRemian = (Module[
      '_JSAUDIOCOM_GetPlayBufferRemian'
    ] = function () {
      return (_JSAUDIOCOM_GetPlayBufferRemian = Module[
        '_JSAUDIOCOM_GetPlayBufferRemian'
      ] =
        Module['asm']['rb']).apply(null, arguments);
    });
    var _JSAUDIOCOM_GetBufferValue = (Module['_JSAUDIOCOM_GetBufferValue'] =
      function () {
        return (_JSAUDIOCOM_GetBufferValue = Module[
          '_JSAUDIOCOM_GetBufferValue'
        ] =
          Module['asm']['sb']).apply(null, arguments);
      });
    var _JSAUDIOCOM_SetPrintLogFlag = (Module['_JSAUDIOCOM_SetPrintLogFlag'] =
      function () {
        return (_JSAUDIOCOM_SetPrintLogFlag = Module[
          '_JSAUDIOCOM_SetPrintLogFlag'
        ] =
          Module['asm']['tb']).apply(null, arguments);
      });
    var _JSAUDIOCOM_SetResampleParam = (Module['_JSAUDIOCOM_SetResampleParam'] =
      function () {
        return (_JSAUDIOCOM_SetResampleParam = Module[
          '_JSAUDIOCOM_SetResampleParam'
        ] =
          Module['asm']['ub']).apply(null, arguments);
      });
    var _JSAUDIOCOM_SetANRParam = (Module['_JSAUDIOCOM_SetANRParam'] =
      function () {
        return (_JSAUDIOCOM_SetANRParam = Module['_JSAUDIOCOM_SetANRParam'] =
          Module['asm']['vb']).apply(null, arguments);
      });
    var _emscripten_tls_init = (Module['_emscripten_tls_init'] = function () {
      return (_emscripten_tls_init = Module['_emscripten_tls_init'] =
        Module['asm']['wb']).apply(null, arguments);
    });
    var ___getTypeName = (Module['___getTypeName'] = function () {
      return (___getTypeName = Module['___getTypeName'] =
        Module['asm']['yb']).apply(null, arguments);
    });
    var ___embind_register_native_and_builtin_types = (Module[
      '___embind_register_native_and_builtin_types'
    ] = function () {
      return (___embind_register_native_and_builtin_types = Module[
        '___embind_register_native_and_builtin_types'
      ] =
        Module['asm']['zb']).apply(null, arguments);
    });
    var _emscripten_current_thread_process_queued_calls = (Module[
      '_emscripten_current_thread_process_queued_calls'
    ] = function () {
      return (_emscripten_current_thread_process_queued_calls = Module[
        '_emscripten_current_thread_process_queued_calls'
      ] =
        Module['asm']['Ab']).apply(null, arguments);
    });
    var _emscripten_main_browser_thread_id = (Module[
      '_emscripten_main_browser_thread_id'
    ] = function () {
      return (_emscripten_main_browser_thread_id = Module[
        '_emscripten_main_browser_thread_id'
      ] =
        Module['asm']['Bb']).apply(null, arguments);
    });
    var _emscripten_sync_run_in_main_thread_4 = (Module[
      '_emscripten_sync_run_in_main_thread_4'
    ] = function () {
      return (_emscripten_sync_run_in_main_thread_4 = Module[
        '_emscripten_sync_run_in_main_thread_4'
      ] =
        Module['asm']['Cb']).apply(null, arguments);
    });
    var _emscripten_main_thread_process_queued_calls = (Module[
      '_emscripten_main_thread_process_queued_calls'
    ] = function () {
      return (_emscripten_main_thread_process_queued_calls = Module[
        '_emscripten_main_thread_process_queued_calls'
      ] =
        Module['asm']['Db']).apply(null, arguments);
    });
    var _emscripten_run_in_main_runtime_thread_js = (Module[
      '_emscripten_run_in_main_runtime_thread_js'
    ] = function () {
      return (_emscripten_run_in_main_runtime_thread_js = Module[
        '_emscripten_run_in_main_runtime_thread_js'
      ] =
        Module['asm']['Eb']).apply(null, arguments);
    });
    var __emscripten_call_on_thread = (Module['__emscripten_call_on_thread'] =
      function () {
        return (__emscripten_call_on_thread = Module[
          '__emscripten_call_on_thread'
        ] =
          Module['asm']['Fb']).apply(null, arguments);
      });
    var __emscripten_thread_exit = (Module['__emscripten_thread_exit'] =
      function () {
        return (__emscripten_thread_exit = Module['__emscripten_thread_exit'] =
          Module['asm']['Gb']).apply(null, arguments);
      });
    var _pthread_testcancel = (Module['_pthread_testcancel'] = function () {
      return (_pthread_testcancel = Module['_pthread_testcancel'] =
        Module['asm']['Hb']).apply(null, arguments);
    });
    var __emscripten_thread_init = (Module['__emscripten_thread_init'] =
      function () {
        return (__emscripten_thread_init = Module['__emscripten_thread_init'] =
          Module['asm']['Ib']).apply(null, arguments);
      });
    var _pthread_self = (Module['_pthread_self'] = function () {
      return (_pthread_self = Module['_pthread_self'] =
        Module['asm']['Jb']).apply(null, arguments);
    });
    var _malloc = (Module['_malloc'] = function () {
      return (_malloc = Module['_malloc'] = Module['asm']['Kb']).apply(
        null,
        arguments
      );
    });
    var stackSave = (Module['stackSave'] = function () {
      return (stackSave = Module['stackSave'] = Module['asm']['Lb']).apply(
        null,
        arguments
      );
    });
    var stackRestore = (Module['stackRestore'] = function () {
      return (stackRestore = Module['stackRestore'] =
        Module['asm']['Mb']).apply(null, arguments);
    });
    var stackAlloc = (Module['stackAlloc'] = function () {
      return (stackAlloc = Module['stackAlloc'] = Module['asm']['Nb']).apply(
        null,
        arguments
      );
    });
    var _emscripten_stack_set_limits = (Module['_emscripten_stack_set_limits'] =
      function () {
        return (_emscripten_stack_set_limits = Module[
          '_emscripten_stack_set_limits'
        ] =
          Module['asm']['Ob']).apply(null, arguments);
      });
    var _free = (Module['_free'] = function () {
      return (_free = Module['_free'] = Module['asm']['Pb']).apply(
        null,
        arguments
      );
    });
    var _memalign = (Module['_memalign'] = function () {
      return (_memalign = Module['_memalign'] = Module['asm']['Qb']).apply(
        null,
        arguments
      );
    });
    var dynCall_jiji = (Module['dynCall_jiji'] = function () {
      return (dynCall_jiji = Module['dynCall_jiji'] =
        Module['asm']['Rb']).apply(null, arguments);
    });
    var __emscripten_allow_main_runtime_queued_calls = (Module[
      '__emscripten_allow_main_runtime_queued_calls'
    ] = 299888);
    var __emscripten_main_thread_futex = (Module[
      '__emscripten_main_thread_futex'
    ] = 373312);
    Module['ccall'] = ccall;
    Module['getValue'] = getValue;
    Module['writeArrayToMemory'] = writeArrayToMemory;
    Module['keepRuntimeAlive'] = keepRuntimeAlive;
    Module['PThread'] = PThread;
    Module['PThread'] = PThread;
    Module['wasmMemory'] = wasmMemory;
    Module['ExitStatus'] = ExitStatus;
    var calledRun;
    function ExitStatus(status) {
      this.name = 'ExitStatus';
      this.message = 'Program terminated with exit(' + status + ')';
      this.status = status;
    }
    dependenciesFulfilled = function runCaller() {
      if (!calledRun) run();
      if (!calledRun) dependenciesFulfilled = runCaller;
    };
    function run(args) {
      args = args || arguments_;
      if (runDependencies > 0) {
        return;
      }
      if (ENVIRONMENT_IS_PTHREAD) {
        readyPromiseResolve(Module);
        initRuntime();
        postMessage({ cmd: 'loaded' });
        return;
      }
      preRun();
      if (runDependencies > 0) {
        return;
      }
      function doRun() {
        if (calledRun) return;
        calledRun = true;
        Module['calledRun'] = true;
        if (ABORT) return;
        initRuntime();
        readyPromiseResolve(Module);
        if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();
        postRun();
      }
      if (Module['setStatus']) {
        Module['setStatus']('Running...');
        setTimeout(function () {
          setTimeout(function () {
            Module['setStatus']('');
          }, 1);
          doRun();
        }, 1);
      } else {
        doRun();
      }
    }
    Module['run'] = run;
    function exit(status, implicit) {
      EXITSTATUS = status;
      if (!implicit) {
        if (ENVIRONMENT_IS_PTHREAD) {
          postMessage({ cmd: 'exitProcess', returnCode: status });
          throw new ExitStatus(status);
        } else {
        }
      }
      if (keepRuntimeAlive()) {
      } else {
        PThread.terminateAllThreads();
        exitRuntime();
      }
      procExit(status);
    }
    function procExit(code) {
      EXITSTATUS = code;
      if (!keepRuntimeAlive()) {
        PThread.terminateAllThreads();
        if (Module['onExit']) Module['onExit'](code);
        ABORT = true;
      }
      quit_(code, new ExitStatus(code));
    }
    if (Module['preInit']) {
      if (typeof Module['preInit'] == 'function')
        Module['preInit'] = [Module['preInit']];
      while (Module['preInit'].length > 0) {
        Module['preInit'].pop()();
      }
    }
    if (ENVIRONMENT_IS_PTHREAD) {
      noExitRuntime = false;
      PThread.initWorker();
    }
    run();

    return JSAudioInterComModule.ready;
  };
})();
if (typeof exports === 'object' && typeof module === 'object')
  module.exports = JSAudioInterComModule;
else if (typeof define === 'function' && define['amd'])
  define([], function () {
    return JSAudioInterComModule;
  });
else if (typeof exports === 'object')
  exports['JSAudioInterComModule'] = JSAudioInterComModule;
